298 lines
12 KiB
Python
298 lines
12 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 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
|