#!/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 logging import time import re import acts.controllers.packet_capture as packet_capture import acts.signals as signals from acts import asserts from acts import utils from acts.test_decorators import test_tracker_info from acts_contrib.test_utils.net import socket_test_utils as sutils from acts_contrib.test_utils.tel import tel_defines from acts_contrib.test_utils.tel import tel_test_utils as tel_utils from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_CONFIG_APBAND_2G from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_CONFIG_APBAND_5G from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_CONFIG_APBAND_AUTO from acts_contrib.test_utils.wifi import wifi_constants from acts_contrib.test_utils.wifi import wifi_test_utils as wutils from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest from acts.controllers.ap_lib.hostapd_constants import CHANNEL_MAP WifiEnums = wutils.WifiEnums class WifiSoftApMultiCountryTest(WifiBaseTest): def __init__(self, configs): super().__init__(configs) self.basetest_name = ( "test_full_tether_startup_auto_one_client_ping_softap_multicountry", "test_full_tether_startup_2G_one_client_ping_softap_multicountry", "test_full_tether_startup_5G_one_client_ping_softap_multicountry", ) self.generate_tests() def generate_testcase(self, basetest_name, country): """Generates a single test case from the given data. Args: basetest_name: The name of the base test case. country: The information about the country code under test. """ base_test = getattr(self, basetest_name) test_tracker_uuid = "" testcase_name = 'test_%s_%s' % (basetest_name, country) test_case = test_tracker_info( uuid=test_tracker_uuid)(lambda: base_test(country)) setattr(self, testcase_name, test_case) self.tests.append(testcase_name) def generate_tests(self): for country in self.user_params['wifi_country_code']: for basetest_name in self.basetest_name: self.generate_testcase(basetest_name, country) def setup_class(self): """It will setup the required dependencies from config file and configure the devices for softap mode testing. Returns: True if successfully configured the requirements for testing. """ super().setup_class() self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] if hasattr(self, 'packet_capture'): self.packet_capture = self.packet_capture[0] self.channel_list_2g = WifiEnums.ALL_2G_FREQUENCIES self.channel_list_5g = WifiEnums.ALL_5G_FREQUENCIES req_params = ["dbs_supported_models"] opt_param = ["open_network"] 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() elif "OpenWrtAP" in self.user_params: self.configure_openwrt_ap_and_start(open_network=True) self.open_network = self.open_network[0]["2g"] # 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) # 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.") wutils.wifi_toggle_state(self.dut, True) wutils.wifi_toggle_state(self.dut_client, True) self.AP_IFACE = 'wlan0' if self.dut.model in self.dbs_supported_models: self.AP_IFACE = 'wlan1' def teardown_class(self): if self.dut.droid.wifiIsApEnabled(): wutils.stop_wifi_tethering(self.dut) wutils.reset_wifi(self.dut) wutils.reset_wifi(self.dut_client) if "AccessPoint" in self.user_params: del self.user_params["reference_networks"] del self.user_params["open_network"] def teardown_test(self): super().teardown_test() if self.dut.droid.wifiIsApEnabled(): wutils.stop_wifi_tethering(self.dut) """ Snifferconfig Functions """ 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) """ Helper Functions """ def create_softap_config(self): """Create a softap config with ssid and password.""" ap_ssid = "softap_" + utils.rand_ascii_str(8) ap_password = utils.rand_ascii_str(8) self.dut.log.info("softap setup: %s %s", ap_ssid, ap_password) config = {wutils.WifiEnums.SSID_KEY: ap_ssid} config[wutils.WifiEnums.PWD_KEY] = ap_password return config def validate_full_tether_startup(self, band=None, test_ping=False): """Test full startup of wifi tethering 1. Report current state. 2. Switch to AP mode. 3. verify SoftAP active. 4. Shutdown wifi tethering. 5. verify back to previous mode. """ initial_wifi_state = self.dut.droid.wifiCheckState() self.dut.log.info("current state: %s", initial_wifi_state) config = self.create_softap_config() wutils.start_wifi_tethering(self.dut, config[wutils.WifiEnums.SSID_KEY], config[wutils.WifiEnums.PWD_KEY], band=band) if test_ping: self.validate_ping_between_softap_and_client(config) wutils.stop_wifi_tethering(self.dut) asserts.assert_false(self.dut.droid.wifiIsApEnabled(), "SoftAp is still reported as running") if initial_wifi_state: wutils.wait_for_wifi_state(self.dut, True) elif self.dut.droid.wifiCheckState(): asserts.fail( "Wifi was disabled before softap and now it is enabled") def validate_ping_between_softap_and_client(self, config): """Test ping between softap and its client. Connect one android device to the wifi hotspot. Verify they can ping each other. Args: config: wifi network config with SSID, password """ wutils.wifi_connect(self.dut_client, config, check_connectivity=False) softap_frequency = int(self.get_wlan1_status(self.dut)['freq']) softap_channel = str(CHANNEL_MAP[softap_frequency]) n = int(softap_channel) if n in range(len(self.channel_list_2g)): softap_band = '2g' else: softap_band = '5g' self.dut.log.info('softap frequency : {}'.format(softap_frequency)) self.dut.log.info('softap channel : {}'.format(softap_channel)) self.dut.log.info('softap band : {}'.format(softap_band)) if hasattr(self, 'packet_capture'): self.conf_packet_capture(softap_band, softap_frequency) dut_ip = self.dut.droid.connectivityGetIPv4Addresses(self.AP_IFACE)[0] dut_client_ip = self.dut_client.droid.connectivityGetIPv4Addresses( 'wlan0')[0] self.dut.log.info("Try to ping %s" % dut_client_ip) asserts.assert_true( utils.adb_shell_ping(self.dut, count=10, dest_ip=dut_client_ip, timeout=20), "%s ping %s failed" % (self.dut.serial, dut_client_ip)) self.dut_client.log.info("Try to ping %s" % dut_ip) asserts.assert_true( utils.adb_shell_ping(self.dut_client, count=10, dest_ip=dut_ip, timeout=20), "%s ping %s failed" % (self.dut_client.serial, dut_ip)) wutils.stop_wifi_tethering(self.dut) 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 """ Tests Begin """ @test_tracker_info(uuid="6ce4fb40-6fa7-452f-ba17-ea3fe47d325d") def test_full_tether_startup_2G_one_client_ping_softap_multicountry( self, country): """(AP) 1 Device can connect to 2G hotspot Steps: 1. Setting country code for each device 2. Turn on DUT's 2G softap 3. Client connects to the softap 4. Client and DUT ping each other """ wutils.set_wifi_country_code(self.dut, country) wutils.set_wifi_country_code(self.dut_client, country) self.validate_full_tether_startup(WIFI_CONFIG_APBAND_2G, test_ping=True) if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) @test_tracker_info(uuid="ae4629e6-08d5-4b51-ac34-6c2485f54df5") def test_full_tether_startup_5G_one_client_ping_softap_multicountry( self, country): """(AP) 1 Device can connect to 2G hotspot Steps: 1. Setting country code for each device 2. Turn on DUT's 5G softap 3. Client connects to the softap 4. Client and DUT ping each other """ wutils.set_wifi_country_code(self.dut, country) wutils.set_wifi_country_code(self.dut_client, country) self.validate_full_tether_startup(WIFI_CONFIG_APBAND_5G, test_ping=True) if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) @test_tracker_info(uuid="84a10203-cb02-433c-92a7-e8aa2348cc02") def test_full_tether_startup_auto_one_client_ping_softap_multicountry( self, country): """(AP) 1 Device can connect to hotspot Steps: 1.Setting country code for each device 2. Turn on DUT's softap 3. Client connects to the softap 4. Client and DUT ping each other """ wutils.set_wifi_country_code(self.dut, country) wutils.set_wifi_country_code(self.dut_client, country) self.validate_full_tether_startup(WIFI_CONFIG_APBAND_AUTO, test_ping=True) if hasattr(self, 'packet_capture'): wutils.stop_pcap(self.packet_capture, self.pcap_procs, False) """ Tests End """ if __name__ == "__main__": pass