Merge Android 14
Bug: 298295554
Merged-In: I5739c9d3b1ae22e06d76007bf51bddd7c71be429
Change-Id: Ia0cf62dad6a04cce046c15f8223a2a599f542e86
diff --git a/acts/framework/acts/controllers/bits.py b/acts/framework/acts/controllers/bits.py
index d89a9b3..caadeb7 100644
--- a/acts/framework/acts/controllers/bits.py
+++ b/acts/framework/acts/controllers/bits.py
@@ -1,5 +1,7 @@
"""Module managing the required definitions for using the bits power monitor"""
+import csv
+import json
import logging
import os
import time
@@ -424,8 +426,14 @@
In the case where there is not enough information to retrieve a
monsoon-like file, this function will do nothing.
"""
- available_channels = self._client.list_channels(
- self._active_collection.name)
+ metrics = self._client.get_metrics(self._active_collection.name)
+
+ try:
+ self._save_rails_csv(metrics)
+ except Exception as e:
+ logging.warning(
+ 'Could not save rails data to csv format with error {}'.format(e))
+ available_channels = [channel['name'] for channel in metrics['data']]
milli_amps_channel = None
for channel in available_channels:
@@ -447,6 +455,70 @@
self._active_collection.name,
milli_amps_channel)
+ def _save_rails_csv(self, metrics):
+ # Creates csv path for rails data
+ monsoon_path = self._active_collection.monsoon_output_path
+ dir_path = os.path.dirname(monsoon_path)
+ if dir_path.endswith('Monsoon'):
+ dir_path = os.path.join(os.path.dirname(dir_path), 'Kibble')
+ os.makedirs(dir_path, exist_ok=True)
+ rails_basename = os.path.basename(monsoon_path)
+ if rails_basename.endswith('.txt'):
+ rails_basename = os.path.splitext(rails_basename)[0]
+ json_basename = 'kibble_rails_' + rails_basename + '.json'
+ rails_basename = 'kibble_rails_' + rails_basename + '.csv'
+ root_rail_results_basename = '{}_results.csv'.format(
+ self._root_rail.split(':')[0])
+ rails_csv_path = os.path.join(dir_path, rails_basename)
+ rails_json_path = os.path.join(dir_path, json_basename)
+ root_rail_results_path = os.path.join(dir_path, root_rail_results_basename)
+
+ logging.info('dump metric to json format: {}'.format(rails_json_path))
+ with open(rails_json_path, 'w') as f:
+ json.dump(metrics['data'], f, sort_keys=True, indent=2)
+
+ # Gets all channels
+ channels = {
+ channel['name'].split('.')[-1].split(':')[0]
+ for channel in metrics['data']
+ }
+ channels = list(channels)
+ list.sort(channels)
+
+ rail_dict = {
+ channel['name'].split('.')[-1] : channel['avg']
+ for channel in metrics['data']
+ }
+
+ root_rail_key = self._root_rail.split(':')[0] + ':mW'
+ root_rail_power = 0
+ if root_rail_key in rail_dict:
+ root_rail_power = rail_dict[root_rail_key]
+ logging.info('root rail {} power is: {}'.format(root_rail_key, root_rail_power))
+
+ path_existed = os.path.exists(root_rail_results_path)
+ with open(root_rail_results_path, 'a') as f:
+ if not path_existed:
+ f.write('{},{}'.format(root_rail_key, 'power(mW)'))
+ f.write('\n{},{}'.format(self._active_collection.name, root_rail_power))
+
+ header = ['CHANNEL', 'VALUE', 'UNIT', 'VALUE', 'UNIT', 'VALUE', 'UNIT']
+ with open(rails_csv_path, 'w') as f:
+ csvwriter = csv.writer(f)
+ csvwriter.writerow(header)
+ for key in channels:
+ if not key.startswith('C') and not key.startswith('M'):
+ continue
+ try:
+ row = [key, '0', 'mA', '0', 'mV', '0', 'mW']
+ row[1] = str(rail_dict[key + ':mA'])
+ row[3] = str(rail_dict[key + ':mV'])
+ row[5] = str(rail_dict[key + ':mW'])
+ csvwriter.writerow(row)
+ logging.debug('channel {}: {}'.format(key, row))
+ except Exception as e:
+ logging.info('channel {} fail'.format(key))
+
def get_waveform(self, file_path=None):
"""Parses a file generated in release_resources.
@@ -462,6 +534,26 @@
return list(power_metrics.import_raw_data(file_path))
+ def get_bits_root_rail_csv_export(self, file_path=None, collection_name=None):
+ """Export raw data samples for root rail in csv format.
+
+ Args:
+ file_path: Path to save the export file.
+ collection_name: Name of collection to be exported on client.
+ """
+ if file_path is None:
+ raise ValueError('file_path cannot be None')
+ if collection_name is None:
+ raise ValueError('collection_name cannot be None')
+ try:
+ key = self._root_rail.split(':')[0] + ':mW'
+ file_name = 'raw_data_' + collection_name + '.csv'
+ raw_bits_data_path = os.path.join(file_path, file_name)
+ self._client.export_as_csv([key], collection_name,
+ raw_bits_data_path)
+ except Exception as e:
+ logging.warning('Failed to save raw data due to : {}'.format(e))
+
def teardown(self):
if self._service is None:
return
diff --git a/acts/framework/acts/controllers/bits_lib/bits_service_config.py b/acts/framework/acts/controllers/bits_lib/bits_service_config.py
index cb2d219..a5fb2f9 100644
--- a/acts/framework/acts/controllers/bits_lib/bits_service_config.py
+++ b/acts/framework/acts/controllers/bits_lib/bits_service_config.py
@@ -144,7 +144,11 @@
if 'serial' not in kibble:
raise ValueError('An individual kibble config must have a '
'serial')
-
+ if 'subkibble_params' in kibble:
+ user_defined_kibble_config = kibble['subkibble_params']
+ kibble_config = copy.deepcopy(user_defined_kibble_config)
+ else:
+ kibble_config = copy.deepcopy(DEFAULT_KIBBLE_CONFIG)
board = kibble['board']
connector = kibble['connector']
serial = kibble['serial']
@@ -154,7 +158,6 @@
self.boards_configs[board][
'board_file'] = kibble_board_file
self.boards_configs[board]['kibble_py'] = kibble_bin
- kibble_config = copy.deepcopy(DEFAULT_KIBBLE_CONFIG)
kibble_config['connector'] = connector
self.boards_configs[board]['attached_kibbles'][
serial] = kibble_config
diff --git a/acts/framework/acts/controllers/buds_lib/dev_utils/proto/gen/apollo_qa_pb2.py b/acts/framework/acts/controllers/buds_lib/dev_utils/proto/gen/apollo_qa_pb2.py
index fefcfe4..1290491 100644
--- a/acts/framework/acts/controllers/buds_lib/dev_utils/proto/gen/apollo_qa_pb2.py
+++ b/acts/framework/acts/controllers/buds_lib/dev_utils/proto/gen/apollo_qa_pb2.py
@@ -11,7 +11,7 @@
_sym_db = _symbol_database.Default()
-import nanopb_pb2 as nanopb__pb2
+from . import nanopb_pb2 as nanopb__pb2
DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0f\x61pollo_qa.proto\x12$apollo.lib.apollo_dev_util_lib.proto\x1a\x0cnanopb.proto\"t\n\rApolloQATrace\x12\x11\n\ttimestamp\x18\x01 \x02(\r\x12\x39\n\x02id\x18\x02 \x02(\x0e\x32-.apollo.lib.apollo_dev_util_lib.proto.TraceId\x12\x15\n\x04\x64\x61ta\x18\x03 \x03(\rB\x07\x10\x01\x92?\x02\x10\x05\"\xcd\x02\n\x16\x41polloQAGetVerResponse\x12\x11\n\ttimestamp\x18\x01 \x02(\r\x12\x16\n\x0e\x63sr_fw_version\x18\x02 \x02(\r\x12\x1a\n\x12\x63sr_fw_debug_build\x18\x03 \x02(\x08\x12\x17\n\x0fvm_build_number\x18\x04 \x02(\r\x12\x16\n\x0evm_debug_build\x18\x05 \x02(\x08\x12\x14\n\x0cpsoc_version\x18\x06 \x02(\r\x12\x1a\n\x0b\x62uild_label\x18\x07 \x02(\tB\x05\x92?\x02\x08 \x12Q\n\x0flast_ota_status\x18\x08 \x01(\x0e\x32\x38.apollo.lib.apollo_dev_util_lib.proto.PreviousBootStatus\x12\x17\n\x0f\x63harger_version\x18\t \x02(\r\x12\x1d\n\x15\x65xpected_psoc_version\x18\n \x01(\r\"u\n\x18\x41polloQAGetCodecResponse\x12\x11\n\ttimestamp\x18\x01 \x02(\r\x12\x46\n\x05\x63odec\x18\x02 \x01(\x0e\x32\x37.apollo.lib.apollo_dev_util_lib.proto.ApolloQAA2dpCodec\"\xa6\x01\n\x1c\x41polloQAGetDspStatusResponse\x12\x11\n\ttimestamp\x18\x01 \x02(\r\x12\x15\n\ris_dsp_loaded\x18\x02 \x02(\x08\x12\x43\n\nsink_state\x18\x03 \x02(\x0e\x32/.apollo.lib.apollo_dev_util_lib.proto.SinkState\x12\x17\n\x0f\x66\x65\x61tures_active\x18\x04 \x02(\r\"\xb9\x01\n\x18\x41polloQAFactoryPlaySound\x12Y\n\x06prompt\x18\x01 \x02(\x0e\x32I.apollo.lib.apollo_dev_util_lib.proto.ApolloQAFactoryPlaySound.PromptType\"B\n\nPromptType\x12\x1c\n\x18PROMPT_TYPE_BT_CONNECTED\x10\x01\x12\x16\n\x12PROMPT_TYPE_IN_EAR\x10\x02\"\x1c\n\x1a\x41polloQAFactoryInfoRequest\"\xb6\x01\n\x1b\x41polloQAFactoryInfoResponse\x12\x11\n\ttimestamp\x18\x01 \x02(\r\x12\x1b\n\x0c\x63rystal_trim\x18\x02 \x01(\x05\x42\x05\x92?\x02\x38\x10\x12\x19\n\x11\x63rash_dump_exists\x18\x03 \x01(\x08\x12!\n\x19is_developer_mode_enabled\x18\x04 \x01(\x08\x12\x1b\n\x13is_always_connected\x18\x05 \x01(\x08\x12\x0c\n\x04hwid\x18\x06 \x01(\r*\xb8\x01\n\x13\x41polloQAMessageType\x12\t\n\x05TRACE\x10\x01\x12\x14\n\x10GET_VER_RESPONSE\x10\x02\x12\x16\n\x12GET_CODEC_RESPONSE\x10\x03\x12\x1b\n\x17GET_DSP_STATUS_RESPONSE\x10\x04\x12\x16\n\x12\x46\x41\x43TORY_PLAY_SOUND\x10\x05\x12\x18\n\x14\x46\x41\x43TORY_INFO_REQUEST\x10\x06\x12\x19\n\x15\x46\x41\x43TORY_INFO_RESPONSE\x10\x07*\xfc\x02\n\x07TraceId\x12\x17\n\x13OTA_ERASE_PARTITION\x10\x01\x12\x1d\n\x19OTA_START_PARTITION_WRITE\x10\x02\x12 \n\x1cOTA_FINISHED_PARTITION_WRITE\x10\x03\x12\x17\n\x13OTA_SIGNATURE_START\x10\x04\x12\x19\n\x15OTA_SIGNATURE_FAILURE\x10\x05\x12\x19\n\x15OTA_TRIGGERING_LOADER\x10\x06\x12\x1c\n\x18OTA_LOADER_VERIFY_FAILED\x10\x07\x12\x10\n\x0cOTA_PROGRESS\x10\x08\x12\x0f\n\x0bOTA_ABORTED\x10\t\x12\x1c\n\x18\x41VRCP_PLAY_STATUS_CHANGE\x10\n\x12\x11\n\rVOLUME_CHANGE\x10\x0b\x12\x1a\n\x16\x43OMMANDER_RECV_COMMAND\x10\x0c\x12\x1c\n\x18\x43OMMANDER_FINISH_COMMAND\x10\r\x12\x1c\n\x18\x43OMMANDER_REJECT_COMMAND\x10\x0e*m\n\x0f\x41vrcpPlayStatus\x12\x0b\n\x07STOPPED\x10\x00\x12\x0b\n\x07PLAYING\x10\x01\x12\n\n\x06PAUSED\x10\x02\x12\x0c\n\x08\x46WD_SEEK\x10\x08\x12\x0c\n\x08REV_SEEK\x10\x10\x12\t\n\x05\x45RROR\x10\x05\x12\r\n\tSEEK_MASK\x10\x18*4\n\x12PreviousBootStatus\x12\x0f\n\x0bOTA_SUCCESS\x10\x01\x12\r\n\tOTA_ERROR\x10\x02*%\n\x11\x41polloQAA2dpCodec\x12\x07\n\x03\x41\x41\x43\x10\x01\x12\x07\n\x03SBC\x10\x02*\xd8\x02\n\tSinkState\x12\t\n\x05LIMBO\x10\x00\x12\x0f\n\x0b\x43ONNECTABLE\x10\x01\x12\x10\n\x0c\x44ISCOVERABLE\x10\x02\x12\r\n\tCONNECTED\x10\x03\x12\x1c\n\x18OUTGOING_CALLS_ESTABLISH\x10\x04\x12\x1c\n\x18INCOMING_CALLS_ESTABLISH\x10\x05\x12\x13\n\x0f\x41\x43TIVE_CALL_SCO\x10\x06\x12\r\n\tTEST_MODE\x10\x07\x12\x1a\n\x16THREE_WAY_CALL_WAITING\x10\x08\x12\x1a\n\x16THREE_WAY_CALL_ON_HOLD\x10\t\x12\x17\n\x13THREE_WAY_MULTICALL\x10\n\x12\x19\n\x15INCOMING_CALL_ON_HOLD\x10\x0b\x12\x16\n\x12\x41\x43TIVE_CALL_NO_SCO\x10\x0c\x12\x12\n\x0e\x41\x32\x44P_STREAMING\x10\r\x12\x16\n\x12\x44\x45VICE_LOW_BATTERY\x10\x0e\x42)\n\x1d\x63om.google.android.bisto.nanoB\x08\x41polloQA')
diff --git a/acts/framework/acts/controllers/cellular_lib/PresetSimulation.py b/acts/framework/acts/controllers/cellular_lib/PresetSimulation.py
index b3c2e5a..d536b09 100644
--- a/acts/framework/acts/controllers/cellular_lib/PresetSimulation.py
+++ b/acts/framework/acts/controllers/cellular_lib/PresetSimulation.py
@@ -27,6 +27,12 @@
KEY_CELL_INFO = "cell_info"
KEY_SCPI_FILE_NAME = "scpi_file"
+ NETWORK_BIT_MASK = {
+ 'nr_lte': '11000001000000000000'
+ }
+ ADB_CMD_LOCK_NETWORK = 'cmd phone set-allowed-network-types-for-users -s 0 {network_bit_mask}'
+ NR_LTE_BIT_MASK_KEY = 'nr_lte'
+
def __init__(self,
simulator,
log,
@@ -47,6 +53,8 @@
super().__init__(simulator, log, dut, test_config, calibration_table,
nr_mode)
+ # require param for idle test case
+ self.rrc_sc_timer = 0
# Set to KeySight APN
log.info('Configuring APN.')
@@ -56,15 +64,6 @@
# Enable roaming on the phone
self.dut.toggle_data_roaming(True)
- # Force device to LTE only so that it connects faster
- try:
- self.dut.set_preferred_network_type(
- BaseCellularDut.PreferredNetworkType.NR_LTE)
- except Exception as e:
- # If this fails the test should be able to run anyways, even if it
- # takes longer to find the cell.
- self.log.warning('Setting preferred RAT failed: ' + str(e))
-
def setup_simulator(self):
"""Do initial configuration in the simulator. """
self.log.info('This simulation does not require initial setup.')
@@ -99,11 +98,7 @@
RuntimeError: simulation fail to start
due to unable to connect dut and cells.
"""
-
- try:
- self.attach()
- except Exception as exc:
- raise RuntimeError('Simulation fail to start.') from exc
+ self.attach()
def attach(self):
"""Attach UE to the callbox.
diff --git a/acts/framework/acts/controllers/spirent_lib/gss7000.py b/acts/framework/acts/controllers/spirent_lib/gss7000.py
index 961d4e8..3f463fc 100644
--- a/acts/framework/acts/controllers/spirent_lib/gss7000.py
+++ b/acts/framework/acts/controllers/spirent_lib/gss7000.py
@@ -162,7 +162,7 @@
Type, list.
"""
root = ET.fromstring(xml)
- capability_ls = list()
+ capability_ls = []
sig_cap_list = root.find('data').find('Signal_capabilities').findall(
'Signal')
for signal in sig_cap_list:
@@ -203,15 +203,13 @@
if scenario == '':
errmsg = ('Missing scenario file')
raise GSS7000Error(error=errmsg, command='load_scenario')
- else:
- self._logger.debug('Stopped the original scenario')
- self._query('-,EN,1')
- cmd = 'SC,' + scenario
- self._logger.debug('Loading scenario')
- self._query(cmd)
- self._logger.debug('Scenario is loaded')
- return True
- return False
+ self._logger.debug('Stopped the original scenario')
+ self._query('-,EN,1')
+ cmd = 'SC,' + scenario
+ self._logger.debug('Loading scenario')
+ self._query(cmd)
+ self._logger.debug('Scenario is loaded')
+ return True
def start_scenario(self, scenario=''):
"""Load and Start the running scenario.
@@ -223,6 +221,8 @@
if scenario:
if self.load_scenario(scenario):
self._query('RU')
+ # TODO: Need to refactor the logic design to solve the comment in ag/19222896
+ # Track the issue in b/241200605
else:
infmsg = 'No scenario is loaded. Stop running scenario'
self._logger.debug(infmsg)
@@ -230,7 +230,7 @@
pass
if scenario:
- infmsg = 'Started running scenario {}'.format(scenario)
+ infmsg = f'Started running scenario {scenario}'
else:
infmsg = 'Started running current scenario'
@@ -279,12 +279,12 @@
GSS7000Error: raise when power offset level is not in [-170, -115] range.
"""
if not -170 <= ref_dBm <= -115:
- errmsg = ('"power_offset" must be within [-170, -115], '
- 'current input is {}').format(str(ref_dBm))
+ errmsg = (f'"power_offset" must be within [-170, -115], '
+ f'current input is {ref_dBm}')
raise GSS7000Error(error=errmsg, command='set_ref_power')
- cmd = 'REF_DBM,{}'.format(str(round(ref_dBm, 1)))
+ cmd = f'REF_DBM,{ref_dBm:.1f}'
self._query(cmd)
- infmsg = 'Set reference power level: {}'.format(str(round(ref_dBm, 1)))
+ infmsg = f'Set reference power level: {ref_dBm:.1f}'
self._logger.debug(infmsg)
def get_status(self, return_txt=False):
@@ -309,8 +309,7 @@
'Waiting for further commands.'
}
return status_dict.get(status)
- else:
- return int(status)
+ return int(status)
def set_power(self, power_level=-130):
"""Set Power Level of GSS7000 Tx
@@ -331,8 +330,7 @@
self.set_power_offset(1, power_offset)
self.set_power_offset(2, power_offset)
- infmsg = 'Set GSS7000 transmit power to "{}"'.format(
- round(power_level, 1))
+ infmsg = f'Set GSS7000 transmit power to "{power_level:.1f}"'
self._logger.debug(infmsg)
def power_lev_offset_cal(self, power_level=-130, sat='GPS', band='L1'):
@@ -418,8 +416,8 @@
f'Satellite system and band ({sat_band}) are not supported.'
f'The GSS7000 support list: {self.capability}')
raise GSS7000Error(error=errmsg, command='set_scenario_power')
- else:
- sat_band_tp = tuple(sat_band.split('_'))
+
+ sat_band_tp = tuple(sat_band.split('_'))
return sat_band_tp
@@ -436,14 +434,14 @@
Default. -130
sat_id: set power level for specific satellite identifiers
Type, int.
- sat_system: to set power level for all Satellites
+ sat_system: to set power level for specific system
Type, str
Option 'GPS/GLO/GAL/BDS'
Type, str
Default, '', assumed to be GPS.
freq_band: Frequency band to set the power level
Type, str
- Option 'L1/L5/B1I/B1C/B2A/F1/E5/ALL'
+ Option 'L1/L5/B1I/B1C/B2A/F1/E5'
Default, '', assumed to be L1.
Raises:
GSS7000Error: raise when power offset is not in [-49, -15] range.
@@ -455,8 +453,7 @@
'B1I': 1,
'B1C': 1,
'F1': 1,
- 'E5': 2,
- 'ALL': 3
+ 'E5': 2
}
# Convert and check satellite system and band
@@ -464,12 +461,13 @@
# Get freq band setting
band_cmd = band_dict.get(band, 1)
+ # When set sat_id --> control specific SV power.
+ # When set is not set --> control all SVs of specific system power.
if not sat_id:
- sat_id = 0
+ sat_id = 1
all_tx_type = 1
else:
all_tx_type = 0
-
# Convert absolute power level to absolute power offset.
power_offset = self.power_lev_offset_cal(power_level, sat, band)
@@ -478,13 +476,10 @@
f'current input is {power_offset}')
raise GSS7000Error(error=errmsg, command='set_power_offset')
+ # If no specific sat_system is set, the default is GPS L1.
if band_cmd == 1:
cmd = f'-,POW_LEV,v1_a1,{power_offset},{sat},{sat_id},0,0,0,1,1,{all_tx_type}'
self._query(cmd)
elif band_cmd == 2:
cmd = f'-,POW_LEV,v1_a2,{power_offset},{sat},{sat_id},0,0,0,1,1,{all_tx_type}'
self._query(cmd)
- elif band_cmd == 3:
- cmd = f'-,POW_LEV,v1_a1,{power_offset},{sat},{sat_id},0,0,0,1,1,{all_tx_type}'
- self._query(cmd)
- cmd = f'-,POW_LEV,v1_a2,{power_offset},{sat},{sat_id},0,0,0,1,1,{all_tx_type}'
diff --git a/acts/framework/acts/controllers/uxm_lib/uxm_cellular_simulator.py b/acts/framework/acts/controllers/uxm_lib/uxm_cellular_simulator.py
index ffb5e16..5ef7eac 100644
--- a/acts/framework/acts/controllers/uxm_lib/uxm_cellular_simulator.py
+++ b/acts/framework/acts/controllers/uxm_lib/uxm_cellular_simulator.py
@@ -11,14 +11,81 @@
# 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 re
+import logging
import os
+import paramiko
import socket
import time
-import paramiko
-import re
from acts.controllers.cellular_simulator import AbstractCellularSimulator
+class SocketWrapper():
+ """A wrapper for socket communicate with test equipment.
+
+ Attributes:
+ _socket: a socket object.
+ _ip: a string value for ip address
+ which we want to connect.
+ _port: an integer for port
+ which we want to connect.
+ _connecting_timeout: an integer for socket connecting timeout.
+ _encode_format: a string specify encoding format.
+ _cmd_terminator: a character indicates the end of command/data
+ which need to be sent.
+ """
+
+ def __init__(self, ip, port,
+ connecting_timeout=120,
+ cmd_terminator='\n',
+ encode_format='utf-8',
+ buff_size=1024):
+ self._socket = None
+ self._ip = ip
+ self._port = port
+ self._connecting_timeout = connecting_timeout
+ self._cmd_terminator = cmd_terminator
+ self._encode_format = encode_format
+ self._buff_size = buff_size
+ self._logger = logging.getLogger(__name__)
+
+ def _connect(self):
+ self._socket = socket.create_connection(
+ (self._ip, self._port), timeout=self._connecting_timeout
+ )
+
+ def send_command(self, cmd: str):
+ if not self._socket:
+ self._connect()
+ if cmd and cmd[-1] != self._cmd_terminator:
+ cmd = cmd + self._cmd_terminator
+ self._socket.sendall(cmd.encode(self._encode_format))
+
+ def send_command_recv(self, cmd: str) -> str:
+ """Send data and wait for response
+
+ Args:
+ cmd: a string command to be sent.
+
+ Returns:
+ a string response.
+ """
+ self.send_command(cmd)
+ response = ''
+ try:
+ response = self._socket.recv(self._buff_size).decode(
+ self._encode_format
+ )
+ except socket.timeout as e:
+ self._logger.info('Socket timeout while receiving response.')
+ self.close()
+ raise
+
+ return response
+
+ def close(self):
+ self._socket.close()
+ self._socket = None
class UXMCellularSimulator(AbstractCellularSimulator):
"""A cellular simulator for UXM callbox."""
@@ -28,20 +95,26 @@
KEY_CELL_TYPE = "cell_type"
# UXM socket port
- UXM_PORT = 5125
+ UXM_SOCKET_PORT = 5125
# UXM SCPI COMMAND
SCPI_IMPORT_STATUS_QUERY_CMD = 'SYSTem:SCPI:IMPort:STATus?'
SCPI_SYSTEM_ERROR_CHECK_CMD = 'SYST:ERR?\n'
+ SCPI_CHECK_CONNECTION_CMD = '*IDN?\n'
+ SCPI_DEREGISTER_UE_IMS = 'SYSTem:IMS:SERVer:UE:DERegister'
# require: path to SCPI file
SCPI_IMPORT_SCPI_FILE_CMD = 'SYSTem:SCPI:IMPort "{}"\n'
# require: 1. cell type (E.g. NR5G), 2. cell number (E.g CELL1)
SCPI_CELL_ON_CMD = 'BSE:CONFig:{}:{}:ACTive 1'
- # require: 1. cell type (E.g. NR5G), 2. cell number (E.g CELL1)
SCPI_CELL_OFF_CMD = 'BSE:CONFig:{}:{}:ACTive 0'
- # require: 1. cell type (E.g. NR5G), 2. cell number (E.g CELL1)
SCPI_GET_CELL_STATUS = 'BSE:STATus:{}:{}?'
- SCPI_CHECK_CONNECTION_CMD = '*IDN?\n'
+ SCPI_RRC_RELEASE_LTE_CMD = 'BSE:FUNCtion:{}:{}:RELease:SEND'
+ SCPI_RRC_RELEASE_NR_CMD = 'BSE:CONFig:{}:{}:RCONtrol:RRC:STARt RRELease'
+ # require cell number
+ SCPI_CREATE_DEDICATED_BEARER = 'BSE:FUNCtion:LTE:{}:NAS:EBID10:DEDicated:CREate'
+ SCPI_CHANGE_SIM_NR_CMD = 'BSE:CONFig:NR5G:CELL1:SECurity:AUTHenticate:KEY:TYPE {}'
+ SCPI_CHANGE_SIM_LTE_CMD = 'BSE:CONFig:LTE:SECurity:AUTHenticate:KEY {}'
+ SCPI_SETTINGS_PRESET_CMD = 'SYSTem:PRESet:FULL'
# UXM's Test Application recovery
TA_BOOT_TIME = 100
@@ -49,11 +122,28 @@
# shh command
SSH_START_GUI_APP_CMD_FORMAT = 'psexec -s -d -i 1 "{exe_path}"'
SSH_CHECK_APP_RUNNING_CMD_FORMAT = 'tasklist | findstr /R {regex_app_name}'
+ SSH_KILL_PROCESS_BY_NAME = 'taskkill /IM {process_name} /F'
+ UXM_TEST_APP_NAME = 'TestApp.exe'
# start process success regex
PSEXEC_PROC_STARTED_REGEX_FORMAT = 'started on * with process ID {proc_id}'
- def __init__(self, ip_address, custom_files, uxm_user,
+ # HCCU default value
+ HCCU_SOCKET_PORT = 4882
+ # number of digit of the length of setup name
+ HCCU_SCPI_CHANGE_SETUP_CMD = ':SYSTem:SETup:CONFig #{number_of_digit}{setup_name_len}{setup_name}'
+ HCCU_SCPI_CHANGE_SCENARIO_CMD = ':SETup:SCENe "((NE_1, {scenario_name}))"'
+ HCCU_STATUS_CHECK_CMD = ':SETup:INSTrument:STATus? 0\n'
+ HCCU_FR2_SETUP_NAME = '{Name:"TSPC_1UXM5G_HF_2RRH_M1740A"}'
+ HCCU_FR1_SETUP_NAME = '{Name:"TSPC_1UXM5G_LF"}'
+ HCCU_GET_INSTRUMENT_COUNT_CMD = ':SETup:INSTrument:COUNt?'
+ HCCU_FR2_INSTRUMENT_COUNT = 5
+ HCCU_FR1_INSTRUMENT_COUNT = 2
+ HCCU_FR2_SCENARIO = 'NR_4DL2x2_2UL2x2_LTE_4CC'
+ HCCU_FR1_SCENARIO = 'NR_1DL4x4_1UL2x2_LTE_4CC'
+
+
+ def __init__(self, ip_address, custom_files,uxm_user,
ssh_private_key_to_uxm, ta_exe_path, ta_exe_name):
"""Initializes the cellular simulator.
@@ -73,10 +163,11 @@
self.cells = []
self.uxm_ip = ip_address
self.uxm_user = uxm_user
- self.ssh_private_key_to_uxm = ssh_private_key_to_uxm
+ self.ssh_private_key_to_uxm = os.path.expanduser(
+ ssh_private_key_to_uxm)
self.ta_exe_path = ta_exe_path
self.ta_exe_name = ta_exe_name
- self.ssh_client = self._create_ssh_client()
+ self.ssh_client = self.create_ssh_client()
# get roclbottom file
for file in self.custom_files:
@@ -85,11 +176,124 @@
# connect to Keysight Test Application via socket
self.recovery_ta()
- self.socket = self._socket_connect(self.uxm_ip, self.UXM_PORT)
+ self.socket = self._socket_connect(self.uxm_ip, self.UXM_SOCKET_PORT)
self.check_socket_connection()
self.timeout = 120
- def _create_ssh_client(self):
+ # hccu socket
+ self.hccu_socket_port = self.HCCU_SOCKET_PORT
+ self.hccu_socket = SocketWrapper(self.uxm_ip, self.hccu_socket_port)
+
+ def socket_connect(self):
+ self.socket = self._socket_connect(self.uxm_ip, self.UXM_SOCKET_PORT)
+
+ def switch_HCCU_scenario(self, scenario_name: str):
+ cmd = self.HCCU_SCPI_CHANGE_SCENARIO_CMD.format(
+ scenario_name=scenario_name)
+ self.hccu_socket.send_command(cmd)
+ self.log.debug(f'Sent command: {cmd}')
+ # this is require for the command to take effect
+ # because hccu's port need to be free.
+ self.hccu_socket.close()
+
+ def switch_HCCU_setup(self, setup_name: str):
+ """Change HHCU system setup.
+
+ Args:
+ setup_name: a string name
+ of the system setup will be changed to.
+ """
+ setup_name_len = str(len(setup_name))
+ number_of_digit = str(len(setup_name_len))
+ cmd = self.HCCU_SCPI_CHANGE_SETUP_CMD.format(
+ number_of_digit=number_of_digit,
+ setup_name_len=setup_name_len,
+ setup_name=setup_name
+ )
+ self.hccu_socket.send_command(cmd)
+ self.log.debug(f'Sent command: {cmd}')
+ # this is require for the command to take effect
+ # because hccu's port need to be free.
+ self.hccu_socket.close()
+
+ def wait_until_hccu_operational(self, timeout=1200):
+ """ Wait for hccu is ready to operate for a specified timeout.
+
+ Args:
+ timeout: time we are waiting for
+ hccu in opertional status.
+
+ Returns:
+ True if HCCU status is operational within timeout.
+ False otherwise.
+ """
+ # check status
+ self.log.info('Waiting for HCCU to ready to operate.')
+ cmd = self.HCCU_STATUS_CHECK_CMD
+ t = 0
+ interval = 10
+ while t < timeout:
+ response = self.hccu_socket.send_command_recv(cmd)
+ if response == 'OPER\n':
+ return True
+ time.sleep(interval)
+ t += interval
+ return False
+
+ def switch_HCCU_settings(self, is_fr2: bool):
+ """Set HCCU setup configuration.
+
+ HCCU stands for Hardware Configuration Control Utility,
+ an interface allows us to control Keysight Test Equipment.
+
+ Args:
+ is_fr2: a bool value.
+ """
+ # change HCCU configration
+ data = ''
+ scenario_name = ''
+ instrument_count_res = self.hccu_socket.send_command_recv(
+ self.HCCU_GET_INSTRUMENT_COUNT_CMD)
+ instrument_count = int(instrument_count_res)
+ # if hccu setup is correct, no need to change.
+ if is_fr2 and instrument_count == self.HCCU_FR2_INSTRUMENT_COUNT:
+ self.log.info('UXM has correct HCCU setup.')
+ return
+ if not is_fr2 and instrument_count == self.HCCU_FR1_INSTRUMENT_COUNT:
+ self.log.info('UXM has correct HCCU setup.')
+ return
+
+ self.log.info('UXM has incorrect HCCU setup, start changing setup.')
+ # terminate TA and close socket
+ self.log.info('Terminate TA before switch HCCU settings.')
+ self.terminate_process(self.UXM_TEST_APP_NAME)
+ self.socket.close()
+
+ # change hccu setup
+ if is_fr2:
+ data = self.HCCU_FR2_SETUP_NAME
+ scenario_name = self.HCCU_FR2_SCENARIO
+ else:
+ data = self.HCCU_FR1_SETUP_NAME
+ scenario_name = self.HCCU_FR1_SCENARIO
+ self.log.info('Switch HCCU setup.')
+ self.switch_HCCU_setup(data)
+ time.sleep(10)
+ if not self.wait_until_hccu_operational():
+ raise RuntimeError('Fail to switch HCCU setup.')
+
+ # change scenario
+ self.log.info('Ativate HCCU scenario.')
+ self.switch_HCCU_scenario(scenario_name)
+ time.sleep(40)
+ if not self.wait_until_hccu_operational():
+ raise RuntimeError('Fail to switch HCCU scenario.')
+
+ # start TA and reconnect socket.
+ self.recovery_ta()
+ self.socket = self._socket_connect(self.uxm_ip, self.UXM_SOCKET_PORT)
+
+ def create_ssh_client(self):
"""Create a ssh client to host."""
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
@@ -99,6 +303,18 @@
self.log.info('SSH client to %s is connected' % self.uxm_ip)
return ssh
+ def terminate_process(self, process_name):
+ cmd = self.SSH_KILL_PROCESS_BY_NAME.format(
+ process_name=process_name
+ )
+ stdin, stdout, stderr = self.ssh_client.exec_command(cmd)
+ stdin.close()
+ err = ''.join(stderr.readlines())
+ out = ''.join(stdout.readlines())
+ final_output = str(out) + str(err)
+ self.log.info(final_output)
+ return out
+
def is_ta_running(self):
is_running_cmd = self.SSH_CHECK_APP_RUNNING_CMD_FORMAT.format(
regex_app_name=self.ta_exe_name)
@@ -141,7 +357,7 @@
retries = 12
for _ in range(retries):
try:
- s = self._socket_connect(self.uxm_ip, self.UXM_PORT)
+ s = self._socket_connect(self.uxm_ip, self.UXM_SOCKET_PORT)
s.close()
return
except ConnectionRefusedError as cre:
@@ -171,6 +387,22 @@
raise ValueError('Missing cell info from configurations file')
self.cells = cell_info
+ def deregister_ue_ims(self):
+ """Remove UE IMS profile from UXM."""
+ self._socket_send_SCPI_command(
+ self.SCPI_DEREGISTER_UE_IMS)
+
+ def create_dedicated_bearer(self):
+ """Create a dedicated bearer setup for ims call.
+
+ After UE connected and register on UXM IMS tab.
+ It is required to create a dedicated bearer setup
+ with EPS bearer ID 10.
+ """
+ cell_number = self.cells[0][self.KEY_CELL_NUMBER]
+ self._socket_send_SCPI_command(
+ self.SCPI_CREATE_DEDICATED_BEARER.format(cell_number))
+
def turn_cell_on(self, cell_type, cell_number):
"""Turn UXM's cell on.
@@ -237,7 +469,7 @@
host: IP address of desktop where Keysight Test Application resides.
port: port that Keysight Test Application is listening for socket
communication.
- Return:
+ Returns:
s: socket object.
"""
self.log.info('Establishing connection to callbox via socket')
@@ -279,7 +511,7 @@
def check_system_error(self):
"""Query system error from Keysight Test Application.
- Return:
+ Returns:
status: a message indicate the number of errors
and detail of errors if any.
a string `0,"No error"` indicates no error.
@@ -296,6 +528,9 @@
path: path to SCPI file.
"""
self._socket_send_SCPI_command(
+ self.SCPI_SETTINGS_PRESET_CMD)
+ time.sleep(10)
+ self._socket_send_SCPI_command(
self.SCPI_IMPORT_SCPI_FILE_CMD.format(path))
time.sleep(45)
@@ -328,13 +563,23 @@
# Restart SL4A
dut.ad.start_services()
+ def set_sim_type(self, is_3gpp_sim):
+ sim_type = 'KEYSight'
+ if is_3gpp_sim:
+ sim_type = 'TEST3GPP'
+ self._socket_send_SCPI_command(
+ self.SCPI_CHANGE_SIM_NR_CMD.format(sim_type))
+ time.sleep(2)
+ self._socket_send_SCPI_command(
+ self.SCPI_CHANGE_SIM_LTE_CMD.format(sim_type))
+ time.sleep(2)
+
def wait_until_attached_one_cell(self,
cell_type,
cell_number,
dut,
wait_for_camp_interval,
- attach_retries,
- change_dut_setting_allow=True):
+ attach_retries):
"""Wait until connect to given UXM cell.
After turn off airplane mode, sleep for
@@ -346,54 +591,74 @@
which we are trying to connect to.
cell_number: ordinal number of a cell
which we are trying to connect to.
- dut: a CellularAndroid controller.
+ dut: a AndroidCellular controller.
wait_for_camp_interval: sleep interval,
wait for device to camp.
attach_retries: number of retry
to wait for device
to connect to 1 basestation.
- change_dut_setting_allow: turn on/off APM
- or reboot device helps with device camp time.
- However, if we are trying to connect to second cell
- changing APM status or reboot is not allowed.
Raise:
- AbstractCellularSimulator.CellularSimulatorError:
- device unable to connect to cell.
+ RuntimeError: device unable to connect to cell.
"""
- # airplane mode off
- # dut.ad.adb.shell('settings put secure adaptive_connectivity_enabled 0')
- dut.toggle_airplane_mode(False)
+ # airplane mode on
+ dut.toggle_airplane_mode(True)
time.sleep(5)
+
# turn cell on
self.turn_cell_on(cell_type, cell_number)
time.sleep(5)
- # waits for connect
+ interval = 10
+ # waits for device to camp
for index in range(1, attach_retries):
- # airplane mode on
- time.sleep(wait_for_camp_interval)
- cell_state = self.get_cell_status(cell_type, cell_number)
- self.log.info(f'cell state: {cell_state}')
- if cell_state == 'CONN\n':
- return True
- if cell_state == 'OFF\n':
+ count = 0
+ # airplane mode off
+ dut.toggle_airplane_mode(False)
+ time.sleep(5)
+ # check connection in small interval
+ while count < wait_for_camp_interval:
+ time.sleep(interval)
+ cell_state = self.get_cell_status(cell_type, cell_number)
+ self.log.info(f'cell state: {cell_state}')
+ if cell_state == 'CONN\n':
+ # wait for connection stable
+ time.sleep(15)
+ # check connection status again
+ cell_state = self.get_cell_status(cell_type, cell_number)
+ self.log.info(f'cell state: {cell_state}')
+ if cell_state == 'CONN\n':
+ return True
+ if cell_state == 'OFF\n':
+ self.turn_cell_on(cell_type, cell_number)
+ time.sleep(5)
+ count += interval
+
+ # reboot device
+ if (index % 2) == 0:
+ dut.ad.reboot()
+ if self.rockbottom_script:
+ self.dut_rockbottom(dut)
+ else:
+ self.log.warning(
+ f'Rockbottom script was not executed after reboot.'
+ )
+ # toggle APM and cell on/off
+ elif (index % 1) == 0:
+ # Toggle APM on
+ dut.toggle_airplane_mode(True)
+ time.sleep(5)
+
+ # Toggle simulator cell
+ self.turn_cell_off(cell_type, cell_number)
+ time.sleep(5)
self.turn_cell_on(cell_type, cell_number)
time.sleep(5)
- if change_dut_setting_allow:
- if (index % 4) == 0:
- dut.ad.reboot()
- if self.rockbottom_script:
- self.dut_rockbottom(dut)
- else:
- self.log.warning(
- f'Rockbottom script {self} was not executed after reboot'
- )
- else:
- # airplane mode on
- dut.toggle_airplane_mode(True)
- time.sleep(5)
- # airplane mode off
- dut.toggle_airplane_mode(False)
+
+ # Toggle APM off
+ dut.toggle_airplane_mode(False)
+ time.sleep(5)
+ # increase length of small waiting interval
+ interval += 5
# Phone cannot connected to basestation of callbox
raise RuntimeError(
@@ -418,37 +683,44 @@
second_cell_number = self.cells[1][self.KEY_CELL_NUMBER]
# connect to 1st cell
- try:
- self.wait_until_attached_one_cell(first_cell_type,
- first_cell_number, dut, timeout,
- attach_retries)
- except Exception as exc:
- raise RuntimeError(f'Cannot connect to first cell') from exc
+ self.wait_until_attached_one_cell(first_cell_type,
+ first_cell_number, dut, timeout,
+ attach_retries)
- # connect to 2nd cell
+ # aggregation to NR
if len(self.cells) == 2:
self.turn_cell_on(
second_cell_type,
second_cell_number,
)
- self._socket_send_SCPI_command(
- 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL None')
- self._socket_send_SCPI_command(
- 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:UL None')
- self._socket_send_SCPI_command(
- 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL CELL1')
- self._socket_send_SCPI_command(
- 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL CELL1')
- time.sleep(1)
- self._socket_send_SCPI_command(
- "BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:APPly")
- try:
- self.wait_until_attached_one_cell(second_cell_type,
- second_cell_number, dut,
- timeout, attach_retries,
- False)
- except Exception as exc:
- raise RuntimeError(f'Cannot connect to second cell') from exc
+
+ for _ in range(1, attach_retries):
+ self.log.info('Try to aggregate to NR.')
+ self._socket_send_SCPI_command(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL None')
+ self._socket_send_SCPI_command(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:UL None')
+ self._socket_send_SCPI_command(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL CELL1')
+ self._socket_send_SCPI_command(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:DL CELL1')
+ time.sleep(1)
+ self._socket_send_SCPI_command(
+ "BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:APPly")
+ # wait for status stable
+ time.sleep(10)
+ cell_state = self.get_cell_status(second_cell_type, second_cell_number)
+ self.log.info(f'cell state: {cell_state}')
+ if cell_state == 'CONN\n':
+ return
+ else:
+ self.turn_cell_off(second_cell_type, second_cell_number)
+ # wait for LTE cell to connect again
+ self.wait_until_attached_one_cell(first_cell_type,
+ first_cell_number, dut, 120,
+ 2)
+
+ raise RuntimeError(f'Fail to aggregate to NR from LTE.')
def set_lte_rrc_state_change_timer(self, enabled, time=10):
"""Configures the LTE RRC state change timer.
@@ -677,16 +949,42 @@
timeout: after this amount of time the method will raise a
CellularSimulatorError exception. Default is 120 seconds.
"""
- raise NotImplementedError(
- 'This UXM callbox simulator does not support this feature.')
+ # turn on RRC release
+ cell_type = self.cells[0][self.KEY_CELL_TYPE]
+ cell_number = self.cells[0][self.KEY_CELL_NUMBER]
+
+ # choose cmd base on cell type
+ cmd = None
+ if cell_type == 'LTE':
+ cmd = self.SCPI_RRC_RELEASE_LTE_CMD
+ else:
+ cmd = self.SCPI_RRC_RELEASE_NR_CMD
+
+ if not cmd:
+ raise RuntimeError(f'Cell type [{cell_type}] is not supporting IDLE.')
+
+ # checking status
+ self.log.info('Wait for IDLE state.')
+ for _ in range(5):
+ cell_state = self.get_cell_status(cell_type, cell_number)
+ self.log.info(f'cell state: {cell_state}')
+ if cell_state == 'CONN\n':
+ # RRC release
+ self._socket_send_SCPI_command(cmd.format(cell_type, cell_number))
+ # wait for status stable
+ time.sleep(60)
+ elif cell_state == 'IDLE\n':
+ return
+
+ raise RuntimeError('RRC release fail.')
def detach(self):
""" Turns off all the base stations so the DUT loose connection."""
for cell in self.cells:
cell_type = cell[self.KEY_CELL_TYPE]
cell_number = cell[self.KEY_CELL_NUMBER]
- self._socket_send_SCPI_command(
- self.SCPI_CELL_OFF_CMD.format(cell_type, cell_number))
+ self.turn_cell_off(cell_type, cell_number)
+ time.sleep(5)
def stop(self):
"""Stops current simulation.
diff --git a/acts_tests/acts_contrib/test_utils/bt/BtMultiprofileBaseTest.py b/acts_tests/acts_contrib/test_utils/bt/BtMultiprofileBaseTest.py
new file mode 100644
index 0000000..f2246df
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/bt/BtMultiprofileBaseTest.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2019 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
+from acts_contrib.test_utils.bt.A2dpBaseTest import A2dpBaseTest
+import acts_contrib.test_utils.bt.BleBaseTest as BleBT
+from acts_contrib.test_utils.power.IperfHelper import IperfHelper
+from acts_contrib.test_utils.bt.bt_test_utils import orchestrate_rfcomm_connection
+from concurrent.futures import ThreadPoolExecutor
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts_contrib.test_utils.tel.tel_test_utils import WIFI_CONFIG_APBAND_2G
+from acts_contrib.test_utils.wifi import wifi_power_test_utils as wputils
+
+
+class BtMultiprofileBaseTest(A2dpBaseTest, BleBT.BleBaseTest):
+ """Base class for BT mutiprofile related tests.
+
+ Inherited from the A2DP Base class, Ble Base class
+ """
+ # Iperf waiting time (margin)
+ IPERF_MARGIN = 10
+
+ def mutiprofile_test(self,
+ codec_config=None,
+ mode=None,
+ victim=None,
+ aggressor=None,
+ metric=None):
+
+ if victim == 'A2DP' and aggressor == 'Ble_Scan' and metric == 'range':
+ scan_callback = self.start_ble_scan(self.dut, mode)
+ self.run_a2dp_to_max_range(codec_config)
+ self.dut.droid.bleStopBleScan(scan_callback)
+ self.log.info("BLE Scan stopped successfully")
+ return True
+
+ if victim == 'Ble_Scan' and aggressor == 'A2DP' and metric == 'scan_accuracy':
+ scan_callback = self.start_ble_scan(self.dut, mode)
+ recorded_file = self.play_and_record_audio(
+ self.audio_params['duration'])
+ self.dut.droid.bleStopBleScan(scan_callback)
+ self.media.stop()
+ self.log.info("BLE Scan & A2DP streaming stopped successfully")
+ return True
+
+ if victim == 'RFCOMM' and aggressor == 'Ble_Scan' and metric == 'throughput':
+ self.remote_device = self.android_devices[2]
+ scan_callback = self.start_ble_scan(self.dut, mode)
+ if not orchestrate_rfcomm_connection(self.dut, self.remote_device):
+ return False
+ self.log.info("RFCOMM Connection established")
+ self.measure_rfcomm_throughput(100)
+ self.dut.droid.bleStopBleScan(scan_callback)
+ self.log.info("BLE Scan stopped successfully")
+
+ if victim == 'A2DP' and aggressor == 'Ble_Adv' and metric == 'range':
+ advertise_callback = self.start_ble_adv(self.dut, mode, 2)
+ self.run_a2dp_to_max_range(codec_config)
+ self.dut.droid.bleStopBleAdvertising(advertise_callback)
+ self.log.info("Advertisement stopped Successfully")
+ return True
+
+ if victim == 'A2DP' and aggressor == 'Ble_conn' and metric == 'range':
+ self.start_ble_connection(self.dut, self.android_devices[2], mode)
+ self.run_a2dp_to_max_range(codec_config)
+ return True
+
+ if victim == 'A2DP' and aggressor == 'wifi' and metric == 'range':
+ self.setup_hotspot_and_connect_client()
+ self.setup_iperf_and_run_throughput()
+ self.run_a2dp_to_max_range(codec_config)
+ self.process_iperf_results()
+ return True
+
+ if victim == 'Ble_Scan' and aggressor == 'wifi' and metric == 'scan_accuracy':
+ scan_callback = self.start_ble_scan(self.dut, mode)
+ self.setup_hotspot_and_connect_client()
+ self.setup_iperf_and_run_throughput()
+ time.sleep(self.audio_params['duration'] + self.IPERF_MARGIN + 2)
+ self.log.info("BLE Scan & iPerf started successfully")
+ self.process_iperf_results()
+ self.dut.droid.bleStopBleScan(scan_callback)
+ self.log.info("BLE Scan stopped successfully")
+ return True
+
+ if victim == 'Ble_Adv' and aggressor == 'wifi' and metric == 'periodic_adv':
+ advertise_callback = self.start_ble_adv(self.dut, mode, 2)
+ self.setup_hotspot_and_connect_client()
+ self.setup_iperf_and_run_throughput()
+ time.sleep(self.audio_params['duration'] + self.IPERF_MARGIN + 2)
+ self.log.info("BLE Advertisement & iPerf started successfully")
+ self.process_iperf_results()
+ self.dut.droid.bleStopBleAdvertising(advertise_callback)
+ self.log.info("Advertisement stopped Successfully")
+ return True
+
+ if victim == 'RFCOMM' and aggressor == 'wifi' and metric == 'throughput':
+ self.remote_device = self.android_devices[2]
+ if not orchestrate_rfcomm_connection(self.dut, self.remote_device):
+ return False
+ self.log.info("RFCOMM Connection established")
+ self.setup_hotspot_and_connect_client()
+ executor = ThreadPoolExecutor(2)
+ throughput = executor.submit(self.measure_rfcomm_throughput, 100)
+ executor.submit(self.setup_iperf_and_run_throughput, )
+ time.sleep(self.audio_params['duration'] + self.IPERF_MARGIN + 10)
+ self.process_iperf_results()
+ return True
+
+ def measure_rfcomm_throughput(self, iteration):
+ """Measures the throughput of a data transfer.
+
+ Sends data over RFCOMM from the client device that is read by the server device.
+ Calculates the throughput for the transfer.
+
+ Args:
+ iteration : An integer value that respesents number of RFCOMM data trasfer iteration
+
+ Returns:
+ The throughput of the transfer in bits per second.
+ """
+ #An integer value designating the number of buffers to be sent.
+ num_of_buffers = 1
+ #An integer value designating the size of each buffer, in bytes.
+ buffer_size = 22000
+ throughput_list = []
+ for transfer in range(iteration):
+ (self.dut.droid.bluetoothConnectionThroughputSend(
+ num_of_buffers, buffer_size))
+
+ throughput = (
+ self.remote_device.droid.bluetoothConnectionThroughputRead(
+ num_of_buffers, buffer_size))
+ throughput = throughput * 8
+ throughput_list.append(throughput)
+ self.log.info(
+ ("RFCOMM Throughput is :{} bits/sec".format(throughput)))
+ throughput = statistics.mean(throughput_list)
+ return throughput
+
+ def setup_hotspot_and_connect_client(self):
+ """
+ Setup hotspot on the remote device and client connects to hotspot
+
+ """
+ self.network = {
+ wutils.WifiEnums.SSID_KEY: 'Pixel_2G',
+ wutils.WifiEnums.PWD_KEY: '1234567890'
+ }
+ # Setup tethering on dut
+ wutils.start_wifi_tethering(self.android_devices[1],
+ self.network[wutils.WifiEnums.SSID_KEY],
+ self.network[wutils.WifiEnums.PWD_KEY],
+ WIFI_CONFIG_APBAND_2G)
+
+ # Connect client device to Hotspot
+ wutils.wifi_connect(self.dut, self.network, check_connectivity=False)
+
+ def setup_iperf_and_run_throughput(self):
+ self.iperf_server_address = self.android_devices[
+ 1].droid.connectivityGetIPv4Addresses('wlan2')[0]
+ # Create the iperf config
+ iperf_config = {
+ 'traffic_type': 'TCP',
+ 'duration': self.audio_params['duration'] + self.IPERF_MARGIN,
+ 'server_idx': 0,
+ 'traffic_direction': 'UL',
+ 'port': self.iperf_servers[0].port,
+ 'start_meas_time': 4,
+ }
+ # Start iperf traffic (dut is the client)
+ self.client_iperf_helper = IperfHelper(iperf_config)
+ self.iperf_servers[0].start()
+ wputils.run_iperf_client_nonblocking(
+ self.dut, self.iperf_server_address,
+ self.client_iperf_helper.iperf_args)
+
+ def process_iperf_results(self):
+ time.sleep(self.IPERF_MARGIN + 2)
+ self.client_iperf_helper.process_iperf_results(self.dut, self.log,
+ self.iperf_servers,
+ self.test_name)
+ self.iperf_servers[0].stop()
+ return True
diff --git a/acts_tests/acts_contrib/test_utils/cellular/__init__.py b/acts_tests/acts_contrib/test_utils/cellular/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/__init__.py
diff --git a/acts_tests/acts_contrib/test_utils/cellular/cellular_base_test.py b/acts_tests/acts_contrib/test_utils/cellular/cellular_base_test.py
index ea7615c..27a66e0 100644
--- a/acts_tests/acts_contrib/test_utils/cellular/cellular_base_test.py
+++ b/acts_tests/acts_contrib/test_utils/cellular/cellular_base_test.py
@@ -201,7 +201,7 @@
if getattr(self, param) is None:
raise RuntimeError('The uxm cellular simulator '
'requires %s to be set in the '
- 'config file.' % key)
+ 'config file.' % param)
return uxm.UXMCellularSimulator(self.uxm_ip, self.custom_files,
self.uxm_user,
self.ssh_private_key_to_uxm,
diff --git a/acts_tests/acts_contrib/test_utils/cellular/keysight_5g_testapp.py b/acts_tests/acts_contrib/test_utils/cellular/keysight_5g_testapp.py
new file mode 100644
index 0000000..8e4d10a
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/keysight_5g_testapp.py
@@ -0,0 +1,864 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2021 - 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 collections
+import pyvisa
+import time
+from acts import logger
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+
+SHORT_SLEEP = 1
+VERY_SHORT_SLEEP = 0.1
+SUBFRAME_DURATION = 0.001
+VISA_QUERY_DELAY = 0.01
+
+
+class Keysight5GTestApp(object):
+ """Controller for the Keysight 5G NR Test Application.
+
+ This controller enables interacting with a Keysight Test Application
+ running on a remote test PC and implements many of the configuration
+ parameters supported in test app.
+ """
+
+ VISA_LOCATION = '/opt/keysight/iolibs/libktvisa32.so'
+
+ def __init__(self, config):
+ self.config = config
+ self.log = logger.create_tagged_trace_logger("{}{}".format(
+ self.config['brand'], self.config['model']))
+ self.resource_manager = pyvisa.ResourceManager(self.VISA_LOCATION)
+ self.test_app = self.resource_manager.open_resource(
+ 'TCPIP0::{}::{}::INSTR'.format(self.config['ip_address'],
+ self.config['hislip_interface']))
+ self.test_app.timeout = 200000
+ self.test_app.write_termination = '\n'
+ self.test_app.read_termination = '\n'
+ self.test_app.query_delay = VISA_QUERY_DELAY
+ self.last_loaded_scpi = None
+
+ inst_id = self.send_cmd('*IDN?', 1)
+ if 'Keysight' not in inst_id[0]:
+ self.log.error(
+ 'Failed to connect to Keysight Test App: {}'.format(inst_id))
+ else:
+ self.log.info("Test App ID: {}".format(inst_id))
+
+ def destroy(self):
+ self.test_app.close()
+
+ ### Programming Utilities
+ @staticmethod
+ def _format_cells(cells):
+ "Helper function to format list of cells."
+ if isinstance(cells, int):
+ return 'CELL{}'.format(cells)
+ elif isinstance(cells, str):
+ return cells
+ elif isinstance(cells, list):
+ cell_list = [
+ Keysight5GTestApp._format_cells(cell) for cell in cells
+ ]
+ cell_list = ','.join(cell_list)
+ return cell_list
+
+ @staticmethod
+ def _format_response(response):
+ "Helper function to format test app response."
+
+ def _format_response_entry(entry):
+ try:
+ formatted_entry = float(entry)
+ except:
+ formatted_entry = entry
+ return formatted_entry
+
+ if ',' not in response:
+ return _format_response_entry(response)
+ response = response.split(',')
+ formatted_response = [
+ _format_response_entry(entry) for entry in response
+ ]
+ return formatted_response
+
+ def send_cmd(self, command, read_response=0, check_errors=1):
+ "Helper function to write to or query test app."
+ if read_response:
+ try:
+ response = Keysight5GTestApp._format_response(
+ self.test_app.query(command))
+ time.sleep(VISA_QUERY_DELAY)
+ if check_errors:
+ error = self.test_app.query('SYSTem:ERRor?')
+ time.sleep(VISA_QUERY_DELAY)
+ if 'No error' not in error:
+ self.log.warning("Command: {}. Error: {}".format(
+ command, error))
+ return response
+ except:
+ raise RuntimeError('Lost connection to test app.')
+ else:
+ try:
+ self.test_app.write(command)
+ time.sleep(VISA_QUERY_DELAY)
+ if check_errors:
+ error = self.test_app.query('SYSTem:ERRor?')
+ if 'No error' not in error:
+ self.log.warning("Command: {}. Error: {}".format(
+ command, error))
+ self.send_cmd('*OPC?', 1)
+ time.sleep(VISA_QUERY_DELAY)
+ except:
+ raise RuntimeError('Lost connection to test app.')
+ return None
+
+ def import_scpi_file(self, file_name, check_last_loaded=0):
+ """Function to import SCPI file specified in file_name.
+
+ Args:
+ file_name: name of SCPI file to run
+ check_last_loaded: flag to check last loaded scpi and
+ only load if different.
+ """
+ if file_name == self.last_loaded_scpi and check_last_loaded:
+ self.log.info('Skipping SCPI import.')
+ self.send_cmd("SYSTem:SCPI:IMPort '{}'".format(file_name))
+ while int(self.send_cmd('SYSTem:SCPI:IMPort:STATus?', 1)):
+ self.send_cmd('*OPC?', 1)
+ self.log.info('Done with SCPI import')
+
+ ### Configure Cells
+ def assert_cell_off_decorator(func):
+ "Decorator function that ensures cells or off when configuring them"
+
+ def inner(self, *args, **kwargs):
+ if "nr" in func.__name__:
+ cell_type = 'NR5G'
+ else:
+ cell_type = kwargs.get('cell_type', args[0])
+ cell = kwargs.get('cell', args[1])
+ cell_state = self.get_cell_state(cell_type, cell)
+ if cell_state:
+ self.log.error('Cell must be off when calling {}'.format(
+ func.__name__))
+ return (func(self, *args, **kwargs))
+
+ return inner
+
+ def assert_cell_off(self, cell_type, cell):
+ cell_state = self.get_cell_state(cell_type, cell)
+ if cell_state:
+ self.log.error('Cell must be off')
+
+ def select_cell(self, cell_type, cell):
+ """Function to select active cell.
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ """
+ self.send_cmd('BSE:SELected:CELL {},{}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell)))
+
+ def select_display_tab(self, cell_type, cell, tab, subtab):
+ """Function to select display tab.
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ tab: tab to display for the selected cell
+ """
+ supported_tabs = {
+ 'PHY': [
+ 'BWP', 'HARQ', 'PDSCH', 'PDCCH', 'PRACH', 'PUSCH', 'PUCCH',
+ 'SRSC'
+ ],
+ 'BTHR': ['SUMMARY', 'OTAGRAPH', 'ULOTA', 'DLOTA'],
+ 'CSI': []
+ }
+ if (tab not in supported_tabs) or (subtab not in supported_tabs[tab]):
+ return
+ self.select_cell(cell_type, cell)
+ self.send_cmd('DISPlay:{} {},{}'.format(cell_type, tab, subtab))
+
+ def get_cell_state(self, cell_type, cell):
+ """Function to get cell on/off state.
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ Returns:
+ cell_state: boolean. True if cell on
+ """
+ cell_state = int(
+ self.send_cmd(
+ 'BSE:CONFig:{}:{}:ACTive:STATe?'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell)), 1))
+ return cell_state
+
+ def wait_for_cell_status(self,
+ cell_type,
+ cell,
+ states,
+ timeout,
+ polling_interval=SHORT_SLEEP):
+ """Function to wait for a specific cell status
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ states: list of acceptable states (ON, CONN, AGG, ACT, etc)
+ timeout: amount of time to wait for requested status
+ Returns:
+ True if one of the listed states is achieved
+ False if timed out waiting for acceptable state.
+ """
+ states = [states] if isinstance(states, str) else states
+ for i in range(int(timeout / polling_interval)):
+ current_state = self.send_cmd(
+ 'BSE:STATus:{}:{}?'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell)), 1)
+ if current_state in states:
+ return True
+ time.sleep(polling_interval)
+ self.log.warning('Timeout waiting for {} {} {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), states))
+ return False
+
+ def set_cell_state(self, cell_type, cell, state):
+ """Function to set cell state
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ state: requested state
+ """
+ self.send_cmd('BSE:CONFig:{}:{}:ACTive:STATe {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), state))
+
+ def set_cell_type(self, cell_type, cell, sa_or_nsa):
+ """Function to set cell duplex mode
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ sa_or_nsa: SA or NSA
+ """
+ self.assert_cell_off(cell_type, cell)
+ self.send_cmd('BSE: CONFig:NR5G:{}:TYPE {}'.format(
+ Keysight5GTestApp._format_cells(cell), sa_or_nsa))
+
+ def set_cell_duplex_mode(self, cell_type, cell, duplex_mode):
+ """Function to set cell duplex mode
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ duplex_mode: TDD or FDD
+ """
+ self.assert_cell_off(cell_type, cell)
+ self.send_cmd('BSE:CONFig:{}:{}:DUPLEX:MODe {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), duplex_mode))
+
+ def set_cell_band(self, cell_type, cell, band):
+ """Function to set cell band
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ band: LTE or NR band (e.g. 1,3,N260, N77)
+ """
+ self.assert_cell_off(cell_type, cell)
+ self.send_cmd('BSE:CONFig:{}:{}:BAND {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), band))
+
+ def set_cell_channel(self, cell_type, cell, channel, arfcn=1):
+ """Function to set cell frequency/channel
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ channel: requested channel (ARFCN) or frequency in MHz
+ """
+ self.assert_cell_off(cell_type, cell)
+ if cell_type == 'NR5G' and isinstance(
+ channel, str) and channel.lower() in ['low', 'mid', 'high']:
+ self.send_cmd('BSE:CONFig:{}:{}:TESTChanLoc {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), channel.upper()))
+ elif arfcn == 1:
+ self.send_cmd('BSE:CONFig:{}:{}:DL:CHANnel {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), channel))
+ else:
+ self.send_cmd('BSE:CONFig:{}:{}:DL:FREQuency:MAIN {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell),
+ channel * 1e6))
+
+ def toggle_contiguous_nr_channels(self, force_contiguous):
+ self.assert_cell_off('NR5G', 1)
+ self.log.warning('Forcing contiguous NR channels overrides channel config.')
+ self.send_cmd('BSE:CONFig:NR5G:PHY:OPTimize:CONTiguous:STATe 0')
+ if force_contiguous:
+ self.send_cmd('BSE:CONFig:NR5G:PHY:OPTimize:CONTiguous:STATe 1')
+
+ def configure_contiguous_nr_channels(self, cell, band, channel):
+ """Function to set cell frequency/channel
+
+ Args:
+ cell: cell/carrier number
+ band: band to set channel in (only required for preset)
+ channel_preset: frequency in MHz or preset in [low, mid, or high]
+ """
+ self.assert_cell_off('NR5G', cell)
+ self.send_cmd('BSE:CONFig:NR5G:PHY:OPTimize:CONTiguous:STATe 0')
+ if channel.lower() in ['low', 'mid', 'high']:
+ pcc_arfcn = cputils.PCC_PRESET_MAPPING[band][channel]
+ self.set_cell_channel('NR5G', cell, pcc_arfcn, 1)
+ else:
+ self.set_cell_channel('NR5G', cell, channel, 0)
+ self.send_cmd('BSE:CONFig:NR5G:PHY:OPTimize:CONTiguous:STATe 1')
+
+ def configure_noncontiguous_nr_channels(self, cells, band, channels):
+ """Function to set cell frequency/channel
+
+ Args:
+ cell: cell/carrier number
+ band: band number
+ channel: frequency in MHz
+ """
+ for cell in cells:
+ self.assert_cell_off('NR5G', cell)
+ self.send_cmd('BSE:CONFig:NR5G:PHY:OPTimize:CONTiguous:STATe 0')
+ for cell, channel in zip(cells, channels):
+ self.set_cell_channel('NR5G', cell, channel, arfcn=0)
+
+ def set_cell_bandwidth(self, cell_type, cell, bandwidth):
+ """Function to set cell bandwidth
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ bandwidth: requested bandwidth
+ """
+ self.assert_cell_off(cell_type, cell)
+ self.send_cmd('BSE:CONFig:{}:{}:DL:BW {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), bandwidth))
+
+ def set_nr_subcarrier_spacing(self, cell, subcarrier_spacing):
+ """Function to set cell bandwidth
+
+ Args:
+ cell: cell/carrier number
+ subcarrier_spacing: requested SCS
+ """
+ self.assert_cell_off('NR5G', cell)
+ self.send_cmd('BSE:CONFig:NR5G:{}:SUBCarrier:SPACing:COMMon {}'.format(
+ Keysight5GTestApp._format_cells(cell), subcarrier_spacing))
+
+ def set_cell_mimo_config(self, cell_type, cell, link, mimo_config):
+ """Function to set cell mimo config.
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ link: uplink or downlink
+ mimo_config: requested mimo configuration (refer to SCPI
+ documentation for allowed range of values)
+ """
+ self.assert_cell_off(cell_type, cell)
+ if cell_type == 'NR5G':
+ self.send_cmd('BSE:CONFig:{}:{}:{}:MIMO:CONFig {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), link,
+ mimo_config))
+ else:
+ self.send_cmd('BSE:CONFig:{}:{}:PHY:DL:ANTenna:CONFig {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), mimo_config))
+
+ def set_lte_cell_transmission_mode(self, cell, transmission_mode):
+ """Function to set LTE cell transmission mode.
+
+ Args:
+ cell: cell/carrier number
+ transmission_mode: one of TM1, TM2, TM3, TM4 ...
+ """
+ self.assert_cell_off('LTE', cell)
+ self.send_cmd('BSE:CONFig:LTE:{}:RRC:TMODe {}'.format(
+ Keysight5GTestApp._format_cells(cell), transmission_mode))
+
+ def set_cell_dl_power(self, cell_type, cell, power, full_bw):
+ """Function to set cell power
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ power: requested power
+ full_bw: boolean controlling if requested power is per channel
+ or subcarrier
+ """
+ if full_bw:
+ self.send_cmd('BSE:CONFIG:{}:{}:DL:POWer:CHANnel {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), power))
+ else:
+ self.send_cmd('BSE:CONFIG:{}:{}:DL:POWer:EPRE {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), power))
+ self.send_cmd('BSE:CONFig:{}:APPLY'.format(cell_type))
+
+ def set_cell_duplex_mode(self, cell_type, cell, duplex_mode):
+ """Function to set cell power
+
+ Args:
+ cell_type: LTE or NR5G cell
+ cell: cell/carrier number
+ duplex mode: TDD or FDD
+ """
+ self.assert_cell_off(cell_type, cell)
+ self.send_cmd('BSE:CONFig:{}:{}:DUPLEX:MODe {}'.format(
+ cell_type, Keysight5GTestApp._format_cells(cell), duplex_mode))
+
+ def set_dl_carriers(self, cells):
+ """Function to set aggregated DL NR5G carriers
+
+ Args:
+ cells: list of DL cells/carriers to aggregate with LTE (e.g. [1,2])
+ """
+ self.send_cmd('BSE:CONFig:NR5G:CELL1:CAGGregation:NRCC:DL {}'.format(
+ Keysight5GTestApp._format_cells(cells)))
+
+ def set_ul_carriers(self, cells):
+ """Function to set aggregated UL NR5G carriers
+
+ Args:
+ cells: list of DL cells/carriers to aggregate with LTE (e.g. [1,2])
+ """
+ self.send_cmd('BSE:CONFig:NR5G:CELL1:CAGGregation:NRCC:UL {}'.format(
+ Keysight5GTestApp._format_cells(cells)))
+
+ def set_nr_cell_schedule_scenario(self, cell, scenario):
+ """Function to set NR schedule to one of predefince quick configs.
+
+ Args:
+ cell: cell number to address. schedule will apply to all cells
+ scenario: one of the predefined test app schedlue quick configs
+ (e.g. FULL_TPUT, BASIC).
+ """
+ self.assert_cell_off('NR5G', cell)
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:{}:SCHeduling:QCONFig:SCENario {}'.format(
+ Keysight5GTestApp._format_cells(cell), scenario))
+ self.send_cmd('BSE:CONFig:NR5G:SCHeduling:QCONFig:APPLy:ALL')
+
+ def set_nr_cell_mcs(self, cell, dl_mcs, ul_mcs):
+ """Function to set NR cell DL & UL MCS
+
+ Args:
+ cell: cell number to address. MCS will apply to all cells
+ dl_mcs: mcs index to use on DL
+ ul_mcs: mcs index to use on UL
+ """
+ self.assert_cell_off('NR5G', cell)
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:SCHeduling:SETParameter "CELLALL:BWPALL:FCALL:SCALL", "DL:IMCS", "{}"'
+ .format(dl_mcs))
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:SCHeduling:SETParameter "CELLALL:BWPALL:FCALL:SCALL", "UL:IMCS", "{}"'
+ .format(ul_mcs))
+
+ def set_lte_cell_mcs(
+ self,
+ cell,
+ dl_mcs_table,
+ dl_mcs,
+ ul_mcs_table,
+ ul_mcs,
+ ):
+ """Function to set NR cell DL & UL MCS
+
+ Args:
+ cell: cell number to address. MCS will apply to all cells
+ dl_mcs: mcs index to use on DL
+ ul_mcs: mcs index to use on UL
+ """
+ if dl_mcs_table == 'QAM256':
+ dl_mcs_table_formatted = 'ASUBframe'
+ elif dl_mcs_table == 'QAM1024':
+ dl_mcs_table_formatted = 'ASUB1024'
+ elif dl_mcs_table == 'QAM64':
+ dl_mcs_table_formatted = 'DISabled'
+ self.assert_cell_off('LTE', cell)
+ self.send_cmd(
+ 'BSE:CONFig:LTE:SCHeduling:SETParameter "CELLALL", "DL:MCS:TABle", "{}"'
+ .format(dl_mcs_table_formatted))
+ self.send_cmd(
+ 'BSE:CONFig:LTE:SCHeduling:SETParameter "CELLALL:SFALL:CWALL", "DL:IMCS", "{}"'
+ .format(dl_mcs))
+ self.send_cmd(
+ 'BSE:CONFig:LTE:SCHeduling:SETParameter "CELLALL", "UL:MCS:TABle", "{}"'
+ .format(ul_mcs_table))
+ self.send_cmd(
+ 'BSE:CONFig:LTE:SCHeduling:SETParameter "CELLALL:SFALL", "UL:IMCS", "{}"'
+ .format(ul_mcs))
+
+ def set_lte_control_region_size(self, cell, num_symbols):
+ self.assert_cell_off('LTE', cell)
+ self.send_cmd('BSE:CONFig:LTE:{}:PHY:PCFich:CFI {}'.format(
+ Keysight5GTestApp._format_cells(cell), num_symbols))
+
+ def set_lte_ul_mac_padding(self, mac_padding):
+ self.assert_cell_off('LTE', 'CELL1')
+ padding_str = 'TRUE' if mac_padding else 'FALSE'
+ self.send_cmd(
+ 'BSE:CONFig:LTE:SCHeduling:SETParameter "CELLALL", "UL:MAC:PADDING", "{}"'
+ .format(padding_str))
+
+ def set_nr_ul_dft_precoding(self, cell, precoding):
+ """Function to configure DFT-precoding on uplink.
+
+ Args:
+ cell: cell number to address. MCS will apply to all cells
+ precoding: 0/1 to disable/enable precoding
+ """
+ self.assert_cell_off('NR5G', cell)
+ precoding_str = "ENABled" if precoding else "DISabled"
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:{}:SCHeduling:QCONFig:UL:TRANsform:PRECoding {}'.
+ format(Keysight5GTestApp._format_cells(cell), precoding_str))
+ precoding_str = "True" if precoding else "False"
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:SCHeduling:SETParameter "CELLALL:BWPALL", "UL:TPEnabled", "{}"'
+ .format(precoding_str))
+
+ def configure_ul_clpc(self, channel, mode, target):
+ """Function to configure UL power control on all cells/carriers
+
+ Args:
+ channel: physical channel must be PUSCh or PUCCh
+ mode: mode supported by test app (all up/down bits, target, etc)
+ target: target power if mode is set to target
+ """
+ self.send_cmd('BSE:CONFig:NR5G:UL:{}:CLPControl:MODE:ALL {}'.format(
+ channel, mode))
+ if "tar" in mode.lower():
+ self.send_cmd(
+ 'BSE:CONFig:NR5G:UL:{}:CLPControl:TARGet:POWer:ALL {}'.format(
+ channel, target))
+
+ def apply_lte_carrier_agg(self, cells):
+ """Function to start LTE carrier aggregation on already configured cells"""
+ if self.wait_for_cell_status('LTE', 'CELL1', 'CONN', 60):
+ self.send_cmd(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:SCC {}'.format(
+ Keysight5GTestApp._format_cells(cells)))
+ self.send_cmd(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:ACTivate:SCC {}'.format(
+ Keysight5GTestApp._format_cells(cells)))
+
+ def apply_carrier_agg(self):
+ """Function to start carrier aggregation on already configured cells"""
+ if self.wait_for_cell_status('LTE', 'CELL1', 'CONN', 60):
+ self.send_cmd(
+ 'BSE:CONFig:LTE:CELL1:CAGGregation:AGGRegate:NRCC:APPly')
+ else:
+ raise RuntimeError('LTE must be connected to start aggregation.')
+
+ def get_ip_throughput(self, cell_type):
+ """Function to query IP layer throughput on LTE or NR
+
+ Args:
+ cell_type: LTE or NR5G
+ Returns:
+ dict containing DL and UL IP-layer throughput
+ """
+ #Tester reply format
+ #{ report-count, total-bytes, current transfer-rate, average transfer-rate, peak transfer-rate }
+ dl_tput = self.send_cmd(
+ 'BSE:MEASure:{}:BTHRoughput:DL:THRoughput:IP?'.format(cell_type),
+ 1)
+ ul_tput = self.send_cmd(
+ 'BSE:MEASure:{}:BTHRoughput:UL:THRoughput:IP?'.format(cell_type),
+ 1)
+ return {'dl_tput': dl_tput, 'ul_tput': ul_tput}
+
+ def _get_throughput(self, cell_type, link, cell):
+ """Helper function to get PHY layer throughput on single cell"""
+ if cell_type == 'LTE':
+ tput_response = self.send_cmd(
+ 'BSE:MEASure:LTE:{}:BTHRoughput:{}:THRoughput:OTA:{}?'.format(
+ Keysight5GTestApp._format_cells(cell), link,
+ Keysight5GTestApp._format_cells(cell)), 1)
+ elif cell_type == 'NR5G':
+ # Tester reply format
+ #progress-count, ack-count, ack-ratio, nack-count, nack-ratio, statdtx-count, statdtx-ratio, pdschBlerCount, pdschBlerRatio, pdschTputRatio.
+ tput_response = self.send_cmd(
+ 'BSE:MEASure:NR5G:BTHRoughput:{}:THRoughput:OTA:{}?'.format(
+ link, Keysight5GTestApp._format_cells(cell)), 1)
+ tput_result = {
+ 'frame_count': tput_response[0] / 1e6,
+ 'current_tput': tput_response[1] / 1e6,
+ 'min_tput': tput_response[2] / 1e6,
+ 'max_tput': tput_response[3] / 1e6,
+ 'average_tput': tput_response[4] / 1e6,
+ 'theoretical_tput': tput_response[5] / 1e6,
+ }
+ return tput_result
+
+ def get_throughput(self, cell_type, cells):
+ """Function to get PHY layer throughput on on or more cells
+
+ This function returns the throughput data on the requested cells
+ during the last BLER test run, i.e., throughpt data must be fetch at
+ the end/after a BLE test run on the Keysight Test App.
+
+ Args:
+ cell_type: LTE or NR5G
+ cells: list of cells to query for throughput data
+ Returns:
+ tput_result: dict containing all throughput statistics in Mbps
+ """
+ if not isinstance(cells, list):
+ cells = [cells]
+ tput_result = collections.OrderedDict()
+ for cell in cells:
+ tput_result[cell] = {
+ 'DL': self._get_throughput(cell_type, 'DL', cell),
+ 'UL': self._get_throughput(cell_type, 'UL', cell)
+ }
+ frame_count = tput_result[cell]['DL']['frame_count']
+ agg_tput = {
+ 'DL': {
+ 'frame_count': frame_count,
+ 'current_tput': 0,
+ 'min_tput': 0,
+ 'max_tput': 0,
+ 'average_tput': 0,
+ 'theoretical_tput': 0
+ },
+ 'UL': {
+ 'frame_count': frame_count,
+ 'current_tput': 0,
+ 'min_tput': 0,
+ 'max_tput': 0,
+ 'average_tput': 0,
+ 'theoretical_tput': 0
+ }
+ }
+ for cell, cell_tput in tput_result.items():
+ for link, link_tput in cell_tput.items():
+ for key, value in link_tput.items():
+ if 'tput' in key:
+ agg_tput[link][key] = agg_tput[link][key] + value
+ tput_result['total'] = agg_tput
+ return tput_result
+
+ def _clear_bler_measurement(self, cell_type):
+ """Helper function to clear BLER results."""
+ if cell_type == 'LTE':
+ self.send_cmd('BSE:MEASure:LTE:CELL1:BTHRoughput:CLEar')
+ elif cell_type == 'NR5G':
+ self.send_cmd('BSE:MEASure:NR5G:BTHRoughput:CLEar')
+
+ def _configure_bler_measurement(self, cell_type, continuous, length):
+ """Helper function to configure BLER results."""
+ if continuous:
+ if cell_type == 'LTE':
+ self.send_cmd('BSE:MEASure:LTE:CELL1:BTHRoughput:CONTinuous 1')
+ elif cell_type == 'NR5G':
+ self.send_cmd('BSE:MEASure:NR5G:BTHRoughput:CONTinuous 1')
+ elif length > 1:
+ if cell_type == 'LTE':
+ self.send_cmd(
+ 'BSE:MEASure:LTE:CELL1:BTHRoughput:LENGth {}'.format(
+ length))
+ self.send_cmd('BSE:MEASure:LTE:CELL1:BTHRoughput:CONTinuous 0')
+ elif cell_type == 'NR5G':
+ self.send_cmd(
+ 'BSE:MEASure:NR5G:BTHRoughput:LENGth {}'.format(length))
+ self.send_cmd('BSE:MEASure:NR5G:BTHRoughput:CONTinuous 0')
+
+ def _set_bler_measurement_state(self, cell_type, state):
+ """Helper function to start or stop BLER measurement."""
+ if cell_type == 'LTE':
+ self.send_cmd(
+ 'BSE:MEASure:LTE:CELL1:BTHRoughput:STATe {}'.format(state))
+ elif cell_type == 'NR5G':
+ self.send_cmd(
+ 'BSE:MEASure:NR5G:BTHRoughput:STATe {}'.format(state))
+
+ def start_bler_measurement(self, cell_type, cells, length):
+ """Function to kick off a BLER measurement
+
+ Args:
+ cell_type: LTE or NR5G
+ length: integer length of BLER measurements in subframes
+ """
+ self._clear_bler_measurement(cell_type)
+ self._set_bler_measurement_state(cell_type, 0)
+ self._configure_bler_measurement(cell_type, 0, length)
+ self._set_bler_measurement_state(cell_type, 1)
+ time.sleep(0.1)
+ bler_check = self.get_bler_result(cell_type, cells, length, 0)
+ if bler_check['total']['DL']['frame_count'] == 0:
+ self.log.warning('BLER measurement did not start. Retrying')
+ self.start_bler_measurement(cell_type, cells, length)
+
+ def _get_bler(self, cell_type, link, cell):
+ """Helper function to get single-cell BLER measurement results."""
+ if cell_type == 'LTE':
+ bler_response = self.send_cmd(
+ 'BSE:MEASure:LTE:CELL1:BTHRoughput:{}:BLER:CELL1?'.format(
+ link), 1)
+ elif cell_type == 'NR5G':
+ bler_response = self.send_cmd(
+ 'BSE:MEASure:NR5G:BTHRoughput:{}:BLER:{}?'.format(
+ link, Keysight5GTestApp._format_cells(cell)), 1)
+ bler_result = {
+ 'frame_count': bler_response[0],
+ 'ack_count': bler_response[1],
+ 'ack_ratio': bler_response[2],
+ 'nack_count': bler_response[3],
+ 'nack_ratio': bler_response[4]
+ }
+ return bler_result
+
+ def get_bler_result(self,
+ cell_type,
+ cells,
+ length,
+ wait_for_length=1,
+ polling_interval=SHORT_SLEEP):
+ """Function to get BLER results.
+
+ This function gets the BLER measurements results on one or more
+ requested cells. The function can either return BLER statistics
+ immediately or wait until a certain number of subframes have been
+ counted (e.g. if the BLER measurement is done)
+
+ Args:
+ cell_type: LTE or NR5G
+ cells: list of cells for which to get BLER
+ length: number of subframes to wait for (typically set to the
+ configured length of the BLER measurements)
+ wait_for_length: boolean to block/wait till length subframes have
+ been counted.
+ Returns:
+ bler_result: dict containing per-cell and aggregate BLER results
+ """
+
+ if not isinstance(cells, list):
+ cells = [cells]
+ while wait_for_length:
+ dl_bler = self._get_bler(cell_type, 'DL', cells[0])
+ if dl_bler['frame_count'] < length:
+ time.sleep(polling_interval)
+ else:
+ break
+
+ bler_result = collections.OrderedDict()
+ for cell in cells:
+ bler_result[cell] = {
+ 'DL': self._get_bler(cell_type, 'DL', cell),
+ 'UL': self._get_bler(cell_type, 'UL', cell)
+ }
+ agg_bler = {
+ 'DL': {
+ 'frame_count': length,
+ 'ack_count': 0,
+ 'ack_ratio': 0,
+ 'nack_count': 0,
+ 'nack_ratio': 0
+ },
+ 'UL': {
+ 'frame_count': length,
+ 'ack_count': 0,
+ 'ack_ratio': 0,
+ 'nack_count': 0,
+ 'nack_ratio': 0
+ }
+ }
+ for cell, cell_bler in bler_result.items():
+ for link, link_bler in cell_bler.items():
+ for key, value in link_bler.items():
+ if 'ack_count' in key:
+ agg_bler[link][key] = agg_bler[link][key] + value
+ dl_ack_nack = agg_bler['DL']['ack_count'] + agg_bler['DL']['nack_count']
+ ul_ack_nack = agg_bler['UL']['ack_count'] + agg_bler['UL']['nack_count']
+ try:
+ agg_bler['DL'][
+ 'ack_ratio'] = agg_bler['DL']['ack_count'] / dl_ack_nack
+ agg_bler['DL'][
+ 'nack_ratio'] = agg_bler['DL']['nack_count'] / dl_ack_nack
+ agg_bler['UL'][
+ 'ack_ratio'] = agg_bler['UL']['ack_count'] / ul_ack_nack
+ agg_bler['UL'][
+ 'nack_ratio'] = agg_bler['UL']['nack_count'] / ul_ack_nack
+ except:
+ self.log.debug(bler_result)
+ agg_bler['DL']['ack_ratio'] = 0
+ agg_bler['DL']['nack_ratio'] = 1
+ agg_bler['UL']['ack_ratio'] = 0
+ agg_bler['UL']['nack_ratio'] = 1
+ bler_result['total'] = agg_bler
+ return bler_result
+
+ def measure_bler(self, cell_type, cells, length):
+ """Function to start and wait for BLER results.
+
+ This function starts a BLER test on a number of cells and waits for the
+ test to complete before returning the BLER measurements.
+
+ Args:
+ cell_type: LTE or NR5G
+ cells: list of cells for which to get BLER
+ length: number of subframes to wait for (typically set to the
+ configured length of the BLER measurements)
+ Returns:
+ bler_result: dict containing per-cell and aggregate BLER results
+ """
+ self.start_bler_measurement(cell_type, cells, length)
+ time.sleep(length * SUBFRAME_DURATION)
+ bler_result = self.get_bler_result(cell_type, cells, length, 1)
+ return bler_result
+
+ def start_nr_rsrp_measurement(self, cells, length):
+ """Function to start 5G NR RSRP measurement.
+
+ Args:
+ cells: list of NR cells to get RSRP on
+ length: length of RSRP measurement in milliseconds
+ Returns:
+ rsrp_result: dict containing per-cell and aggregate BLER results
+ """
+ for cell in cells:
+ self.send_cmd('BSE:MEASure:NR5G:{}:L1:RSRPower:STOP'.format(
+ Keysight5GTestApp._format_cells(cell)))
+ for cell in cells:
+ self.send_cmd('BSE:MEASure:NR5G:{}:L1:RSRPower:LENGth {}'.format(
+ Keysight5GTestApp._format_cells(cell), length))
+ for cell in cells:
+ self.send_cmd('BSE:MEASure:NR5G:{}:L1:RSRPower:STARt'.format(
+ Keysight5GTestApp._format_cells(cell)))
+
+ def get_nr_rsrp_measurement_state(self, cells):
+ for cell in cells:
+ self.log.info(
+ self.send_cmd(
+ 'BSE:MEASure:NR5G:{}:L1:RSRPower:STATe?'.format(
+ Keysight5GTestApp._format_cells(cell)), 1))
+
+ def get_nr_rsrp_measurement_results(self, cells):
+ for cell in cells:
+ self.log.info(
+ self.send_cmd(
+ 'BSE:MEASure:NR5G:{}:L1:RSRPower:REPorts:JSON?'.format(
+ Keysight5GTestApp._format_cells(cell)), 1))
diff --git a/acts_tests/acts_contrib/test_utils/cellular/keysight_catr_chamber.py b/acts_tests/acts_contrib/test_utils/cellular/keysight_catr_chamber.py
new file mode 100644
index 0000000..bd7540d
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/keysight_catr_chamber.py
@@ -0,0 +1,181 @@
+# Copyright 2020 Google Inc. All Rights Reserved.
+# Author: oelayach@google.com
+
+import pyvisa
+import time
+from acts import logger
+from ota_chamber import Chamber
+
+
+class Chamber(Chamber):
+ """Base class implementation for signal generators.
+
+ Base class provides functions whose implementation is shared by all
+ chambers.
+ """
+ CHAMBER_SLEEP = 10
+
+ def __init__(self, config):
+ self.config = config
+ self.log = logger.create_tagged_trace_logger("{}{}".format(
+ self.config['brand'], self.config['model']))
+ self.chamber_resource = pyvisa.ResourceManager()
+ self.chamber_inst = self.chamber_resource.open_resource(
+ '{}::{}::{}::INSTR'.format(self.config['network_id'],
+ self.config['ip_address'],
+ self.config['hislip_interface']))
+ self.chamber_inst.timeout = 200000
+ self.chamber_inst.write_termination = '\n'
+ self.chamber_inst.read_termination = '\n'
+
+ self.id_check(self.config)
+ self.current_azim = 0
+ self.current_roll = 0
+ if self.config.get('reset_home', True):
+ self.find_chamber_home()
+ self.move_theta_phi_abs(self.config['chamber_home']['theta'],
+ self.config['chamber_home']['phi'])
+ self.set_new_home_position()
+ else:
+ self.config['chamber_home'] = {'phi': 0, 'theta': 0}
+ self.log.warning(
+ 'Reset home set to false. Assumed [0,0]. Chamber angles may not be as expected.'
+ )
+
+ def id_check(self, config):
+ """ Checks Chamber ID."""
+ self.log.info("ID Check Successful.")
+ self.log.info(self.chamber_inst.query("*IDN?"))
+
+ def reset(self):
+ self.reset_phi_theta()
+
+ def disconnect(self):
+ if self.config.get('reset_home', True):
+ self.reset_phi_theta()
+ self.chamber_inst.close()
+ self.chamber_resource.close()
+
+ def find_chamber_home(self):
+ self.chamber_inst.write(f"POS:BOR:INIT")
+ self.set_new_home_position()
+ self.wait_for_move_end()
+
+ def set_new_home_position(self):
+ self.chamber_inst.write(f"POS:ZERO:RES")
+
+ def get_phi(self):
+ return self.current_azim
+
+ def get_theta(self):
+ return self.current_roll
+
+ def get_pattern_sweep_limits(self):
+ return {
+ "pattern_phi_start": -self.config['chamber_home']['phi'],
+ "pattern_phi_stop": 165 - self.config['chamber_home']['phi'],
+ "pattern_theta_start": -self.config['chamber_home']['theta'],
+ "pattern_theta_stop": 360 - self.config['chamber_home']['theta'],
+ }
+
+ def move_phi_abs(self, phi):
+ self.log.info("Moving to Phi={}".format(phi))
+ self.move_to_azim_roll(phi, self.current_roll)
+
+ def move_theta_abs(self, theta):
+ self.log.info("Moving to Theta={}".format(theta))
+ self.move_to_azim_roll(self.current_azim, theta)
+
+ def move_theta_phi_abs(self, theta, phi):
+ self.log.info("Moving chamber to [{}, {}]".format(theta, phi))
+ self.move_to_azim_roll(phi, theta)
+
+ def move_phi_rel(self, phi):
+ self.log.info("Moving Phi by {} degrees".format(phi))
+ self.move_to_azim_roll(self.current_azim + phi, self.current_roll)
+
+ def move_theta_rel(self, theta):
+ self.log.info("Moving Theta by {} degrees".format(theta))
+ self.move_to_azim_roll(self.current_azim, self.current_roll + theta)
+
+ def move_feed_roll(self, roll):
+ self.log.info("Moving feed roll to {} degrees".format(roll))
+ self.chamber_inst.write(f"POS:MOVE:ROLL:FEED {roll}")
+ self.chamber_inst.write("POS:MOVE:INIT")
+ self.wait_for_move_end()
+ self.current_feed_roll = self.chamber_inst.query("POS:MOVE:ROLL:FEED?")
+
+ def reset_phi(self):
+ self.log.info("Resetting Phi.")
+ self.move_to_azim_roll(0, self.current_roll)
+ self.phi = 0
+
+ def reset_theta(self):
+ self.log.info("Resetting Theta.")
+ self.move_to_azim_roll(self.current_azim, 0)
+ self.theta = 0
+
+ def reset_phi_theta(self):
+ """ Resets signal generator."""
+ self.log.info("Resetting to home.")
+ self.chamber_inst.write(f"POS:ZERO:GOTO")
+ self.wait_for_move_end()
+
+ # Keysight-provided functions
+ def wait_for_move_end(self):
+ moving_bitmask = 4
+ while True:
+ stat = int(self.chamber_inst.query("STAT:OPER:COND?"))
+ if (stat & moving_bitmask) == 0:
+ return
+ time.sleep(0.25)
+
+ def wait_for_sweep_end(self):
+ sweeping_bitmask = 16
+ while True:
+ stat = int(self.chamber_inst.query("STAT:OPER:COND?"))
+ if (stat & sweeping_bitmask) == 0:
+ return
+ time.sleep(0.25)
+
+ def move_to_azim_roll(self, azim, roll):
+ self.chamber_inst.write(f"POS:MOVE:AZIM {azim};ROLL {roll}")
+ self.chamber_inst.write("POS:MOVE:INIT")
+ self.wait_for_move_end()
+ curr_motor = self.chamber_inst.query("POS:CURR:MOT?")
+ curr_azim, curr_roll = map(float, (curr_motor.split(',')))
+ self.current_azim = curr_azim
+ self.current_roll = curr_roll
+ return curr_azim, curr_roll
+
+ def sweep_setup(self, azim_sss: tuple, roll_sss: tuple, sweep_type: str):
+ self.chamber_inst.write(
+ f"POS:SWE:AZIM:STAR {azim_sss[0]};STOP {azim_sss[1]};STEP {azim_sss[2]}"
+ )
+ self.chamber_inst.write(
+ f"POS:SWE:ROLL:STAR {roll_sss[0]};STOP {roll_sss[1]};STEP {roll_sss[2]}"
+ )
+ self.chamber_inst.write(f"POS:SWE:TYPE {sweep_type}")
+ self.chamber_inst.write("POS:SWE:CONT 1")
+
+ def sweep_init(self):
+
+ def query_float_list(inst, scpi):
+ resp = inst.query(scpi)
+ return list(map(float, resp.split(',')))
+
+ self.chamber_inst.write("POS:SWE:INIT")
+ self.wait_for_sweep_end()
+ azims = query_float_list(self.chamber_inst, "FETC:AZIM?")
+ rolls = query_float_list(self.chamber_inst, "FETC:ROLL?")
+ phis = query_float_list(self.chamber_inst, "FETC:DUT:PHI?")
+ thetas = query_float_list(self.chamber_inst, "FETC:DUT:THET?")
+ return zip(azims, rolls, phis, thetas)
+
+ def configure_positioner(self, pos_name, pos_visa_addr):
+ select = "True"
+ simulate = "False"
+ options = ""
+ data = f"'{pos_name}~{select}~{simulate}~{pos_visa_addr}~{options}'"
+ self.chamber_inst.write(f"EQU:CONF {data}")
+ self.chamber_inst.write("EQU:UPD")
diff --git a/acts_tests/acts_contrib/test_utils/cellular/mock_chamber.py b/acts_tests/acts_contrib/test_utils/cellular/mock_chamber.py
new file mode 100644
index 0000000..36d74c5
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/mock_chamber.py
@@ -0,0 +1,65 @@
+# Copyright 2020 Google Inc. All Rights Reserved.
+# Author: oelayach@google.com
+from acts import logger
+from ota_chamber import Chamber
+
+
+class MockChamber(Chamber):
+ """Base class implementation for signal generators.
+
+ Base class provides functions whose implementation is shared by all
+ chambers.
+ """
+
+ def __init__(self, config):
+ self.config = config
+ self.log = logger.create_tagged_trace_logger("{}{}".format(
+ self.config['brand'], self.config['model']))
+ self.id_check(self.config)
+ self.reset()
+
+ def id_check(self, config):
+ """ Check Chamber."""
+ self.log.info("ID Check Successful.")
+
+ def reset(self):
+ """ Resets Chamber."""
+ self.log.info("Resetting instrument.")
+
+ def disconnect(self):
+ """ Disconnects Chamber."""
+ self.log.info("Disconnecting instrument.")
+
+ def get_phi(self):
+ return self.phi
+
+ def get_theta(self):
+ return self.phi
+
+ def move_phi_abs(self, phi):
+ self.log.info("Moving to Phi={}".format(phi))
+ self.phi = phi
+
+ def move_theta_abs(self, theta):
+ self.log.info("Moving to Theta={}".format(theta))
+ self.theta = theta
+
+ def move_phi_rel(self, phi):
+ self.log.info("Moving Phi by {} degrees".format(phi))
+ self.phi = self.phi + phi
+
+ def move_theta_rel(self, theta):
+ self.log.info("Moving Theta by {} degrees".format(theta))
+ self.theta = self.theta + theta
+
+ def reset_phi(self):
+ self.log.info("Resetting Phi.")
+ self.phi = 0
+
+ def reset_theta(self):
+ self.log.info("Resetting Theta.")
+ self.theta = 0
+
+ def reset_phi_theta(self):
+ """ Resets signal generator."""
+ self.log.info("Resetting to home.")
diff --git a/acts_tests/acts_contrib/test_utils/cellular/ota_chamber.py b/acts_tests/acts_contrib/test_utils/cellular/ota_chamber.py
new file mode 100644
index 0000000..923f22b
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/ota_chamber.py
@@ -0,0 +1,94 @@
+# Copyright 2020 Google Inc. All Rights Reserved.
+# Author: oelayach@google.com
+
+import importlib
+from acts import logger
+
+ACTS_CONTROLLER_CONFIG_NAME = 'Chamber'
+
+
+def create(configs):
+ """Factory method for Signal Generators.
+
+ Args:
+ configs: list of dicts with signal generator settings
+ """
+ SUPPORTED_MODELS = {
+ ("Keysight", "CATR"): "lassen.controllers.chamber.KeysightCATRChamber",
+ ("Mock", "Chamber"): "lassen.controllers.chamber.MockChamber"
+ }
+ objs = []
+ for config in configs:
+ if (config["brand"], config["model"]) not in SUPPORTED_MODELS:
+ raise ValueError("Not a valid chamber model.")
+ module = importlib.import_module(SUPPORTED_MODELS[(config["brand"],
+ config["model"])])
+ chamber = module.Chamber(config)
+ objs.append(chamber)
+ return objs
+
+
+def destroy(devices):
+ for device in devices:
+ device.reset()
+
+
+class Chamber():
+ """Base class implementation for signal generators.
+
+ Base class provides functions whose implementation is shared by all
+ chambers.
+ """
+
+ def __init__(self, config):
+ self.config = config
+ self.log = logger.create_tagged_trace_logger("{}{}".format(
+ self.config['brand'], self.config['model']))
+ self.id_check(self.config)
+ self.reset()
+
+ def id_check(self, config):
+ """ Resets signal generator."""
+ self.log.info("ID Check Successful.")
+
+ def reset(self):
+ """ Resets signal generator."""
+ self.log.info("Resetting instrument.")
+
+ def disconnect(self):
+ """ Disconnects Chamber."""
+ self.log.info("Disconnecting instrument.")
+
+ def get_phi(self):
+ return self.phi
+
+ def get_theta(self):
+ return self.phi
+
+ def move_phi_abs(self, phi):
+ self.log.info("Moving to Phi={}".format(phi))
+ self.phi = phi
+
+ def move_theta_abs(self, theta):
+ self.log.info("Moving to Theta={}".format(theta))
+ self.theta = theta
+
+ def move_phi_rel(self, phi):
+ self.log.info("Moving Phi by {} degrees".format(phi))
+ self.phi = self.phi + phi
+
+ def move_theta_rel(self, theta):
+ self.log.info("Moving Theta by {} degrees".format(theta))
+ self.theta = self.theta + theta
+
+ def reset_phi(self):
+ self.log.info("Resetting Phi.")
+ self.phi = 0
+
+ def reset_theta(self):
+ self.log.info("Resetting Theta.")
+ self.theta = 0
+
+ def reset_phi_theta(self):
+ """ Resets signal generator."""
+ self.log.info("Resetting to home.")
diff --git a/acts_tests/acts_contrib/test_utils/cellular/performance/CellularThroughputBaseTest.py b/acts_tests/acts_contrib/test_utils/cellular/performance/CellularThroughputBaseTest.py
new file mode 100644
index 0000000..57e66ff
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/performance/CellularThroughputBaseTest.py
@@ -0,0 +1,481 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import json
+import re
+
+import numpy
+import os
+import time
+from acts import asserts
+from acts import context
+from acts import base_test
+from acts import utils
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts.controllers.utils_lib import ssh
+from acts.controllers import iperf_server as ipf
+from acts_contrib.test_utils.cellular.keysight_5g_testapp import Keysight5GTestApp
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from functools import partial
+
+LONG_SLEEP = 10
+MEDIUM_SLEEP = 2
+IPERF_TIMEOUT = 10
+SHORT_SLEEP = 1
+SUBFRAME_LENGTH = 0.001
+STOP_COUNTER_LIMIT = 3
+
+
+class CellularThroughputBaseTest(base_test.BaseTestClass):
+ """Base class for Cellular Throughput Testing
+
+ This base class enables cellular throughput tests on a lab/callbox setup
+ with PHY layer or iperf traffic.
+ """
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = None
+
+ def setup_class(self):
+ """Initializes common test hardware and parameters.
+
+ This function initializes hardwares and compiles parameters that are
+ common to all tests in this class.
+ """
+ # Setup controllers
+ self.dut = self.android_devices[-1]
+ self.keysight_test_app = Keysight5GTestApp(
+ self.user_params['Keysight5GTestApp'])
+ self.iperf_server = self.iperf_servers[0]
+ self.iperf_client = self.iperf_clients[0]
+ self.remote_server = ssh.connection.SshConnection(
+ ssh.settings.from_config(
+ self.user_params['RemoteServer']['ssh_config']))
+
+ # Configure Tester
+ if self.testclass_params.get('reload_scpi', 1):
+ self.keysight_test_app.import_scpi_file(
+ self.testclass_params['scpi_file'])
+
+ # Declare testclass variables
+ self.testclass_results = collections.OrderedDict()
+
+ # Configure test retries
+ self.user_params['retry_tests'] = [self.__class__.__name__]
+
+ # Turn Airplane mode on
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+
+ def teardown_class(self):
+ self.log.info('Turning airplane mode on')
+ try:
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ except:
+ self.log.warning('Cannot perform teardown operations on DUT.')
+ try:
+ self.keysight_test_app.set_cell_state('LTE', 1, 0)
+ self.keysight_test_app.destroy()
+ except:
+ self.log.warning('Cannot perform teardown operations on tester.')
+ self.process_testclass_results()
+
+ def setup_test(self):
+ self.retry_flag = False
+ if self.testclass_params['enable_pixel_logs']:
+ cputils.start_pixel_logger(self.dut)
+
+ def teardown_test(self):
+ self.retry_flag = False
+ self.log.info('Turing airplane mode on')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ if self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE off.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 0)
+ log_path = os.path.join(
+ context.get_current_context().get_full_output_path(), 'pixel_logs')
+ os.makedirs(self.log_path, exist_ok=True)
+ if self.testclass_params['enable_pixel_logs']:
+ cputils.stop_pixel_logger(self.dut, log_path)
+ self.process_testcase_results()
+ self.pass_fail_check()
+
+ def on_retry(self):
+ """Function to control test logic on retried tests.
+
+ This function is automatically executed on tests that are being
+ retried. In this case the function resets wifi, toggles it off and on
+ and sets a retry_flag to enable further tweaking the test logic on
+ second attempts.
+ """
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ if self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE off.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 0)
+ self.retry_flag = True
+
+ def pass_fail_check(self):
+ pass
+
+ def process_testcase_results(self):
+ pass
+
+ def process_testclass_results(self):
+ pass
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ raise NotImplementedError(
+ 'get_per_cell_power_sweeps must be implemented.')
+
+ def compile_test_params(self, testcase_params):
+ """Function that completes all test params based on the test name.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ """
+ # Measurement Duration
+ testcase_params['bler_measurement_length'] = int(
+ self.testclass_params['traffic_duration'] / SUBFRAME_LENGTH)
+ # Cell power sweep
+ # TODO: Make this a function to support single power and sweep modes for each cell
+ testcase_params['cell_power_sweep'] = self.get_per_cell_power_sweeps(
+ testcase_params)
+ # Traffic & iperf params
+ if self.testclass_params['traffic_type'] == 'PHY':
+ return testcase_params
+ if self.testclass_params['traffic_type'] == 'TCP':
+ testcase_params['iperf_socket_size'] = self.testclass_params.get(
+ 'tcp_socket_size', None)
+ testcase_params['iperf_processes'] = self.testclass_params.get(
+ 'tcp_processes', 1)
+ elif self.testclass_params['traffic_type'] == 'UDP':
+ testcase_params['iperf_socket_size'] = self.testclass_params.get(
+ 'udp_socket_size', None)
+ testcase_params['iperf_processes'] = self.testclass_params.get(
+ 'udp_processes', 1)
+ adb_iperf_server = isinstance(self.iperf_server,
+ ipf.IPerfServerOverAdb)
+ if testcase_params['traffic_direction'] == 'DL':
+ reverse_direction = 0 if adb_iperf_server else 1
+ testcase_params[
+ 'use_client_output'] = False if adb_iperf_server else True
+ elif testcase_params['traffic_direction'] == 'UL':
+ reverse_direction = 1 if adb_iperf_server else 0
+ testcase_params[
+ 'use_client_output'] = True if adb_iperf_server else False
+ testcase_params['iperf_args'] = wputils.get_iperf_arg_string(
+ duration=self.testclass_params['traffic_duration'],
+ reverse_direction=reverse_direction,
+ traffic_type=self.testclass_params['traffic_type'],
+ socket_size=testcase_params['iperf_socket_size'],
+ num_processes=testcase_params['iperf_processes'],
+ udp_throughput=self.testclass_params['UDP_rates'].get(
+ testcase_params['num_dl_cells'],
+ self.testclass_params['UDP_rates']["default"]),
+ udp_length=1440)
+ return testcase_params
+
+ def run_iperf_traffic(self, testcase_params):
+ self.iperf_server.start(tag=0)
+ dut_ip = self.dut.droid.connectivityGetIPv4Addresses('rmnet0')[0]
+ if 'iperf_server_address' in self.testclass_params:
+ iperf_server_address = self.testclass_params[
+ 'iperf_server_address']
+ elif isinstance(self.iperf_server, ipf.IPerfServerOverAdb):
+ iperf_server_address = dut_ip
+ else:
+ iperf_server_address = wputils.get_server_address(
+ self.remote_server, dut_ip, '255.255.255.0')
+ client_output_path = self.iperf_client.start(
+ iperf_server_address, testcase_params['iperf_args'], 0,
+ self.testclass_params['traffic_duration'] + IPERF_TIMEOUT)
+ server_output_path = self.iperf_server.stop()
+ # 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)
+ current_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')
+ current_throughput = 0
+ return current_throughput
+
+ def run_single_throughput_measurement(self, testcase_params):
+ result = collections.OrderedDict()
+ self.log.info('Starting BLER & throughput tests.')
+ if testcase_params['endc_combo_config']['nr_cell_count']:
+ self.keysight_test_app.start_bler_measurement(
+ 'NR5G', testcase_params['endc_combo_config']['nr_dl_carriers'],
+ testcase_params['bler_measurement_length'])
+ if testcase_params['endc_combo_config']['lte_cell_count']:
+ self.keysight_test_app.start_bler_measurement(
+ 'LTE', testcase_params['endc_combo_config']['lte_carriers'][0],
+ testcase_params['bler_measurement_length'])
+
+ if self.testclass_params['traffic_type'] != 'PHY':
+ result['iperf_throughput'] = self.run_iperf_traffic(
+ testcase_params)
+
+ if testcase_params['endc_combo_config']['nr_cell_count']:
+ result['nr_bler_result'] = self.keysight_test_app.get_bler_result(
+ 'NR5G', testcase_params['endc_combo_config']['nr_dl_carriers'],
+ testcase_params['bler_measurement_length'])
+ result['nr_tput_result'] = self.keysight_test_app.get_throughput(
+ 'NR5G', testcase_params['endc_combo_config']['nr_dl_carriers'])
+ if testcase_params['endc_combo_config']['lte_cell_count']:
+ result['lte_bler_result'] = self.keysight_test_app.get_bler_result(
+ 'LTE', testcase_params['endc_combo_config']['lte_carriers'],
+ testcase_params['bler_measurement_length'])
+ result['lte_tput_result'] = self.keysight_test_app.get_throughput(
+ 'LTE', testcase_params['endc_combo_config']['lte_carriers'])
+ return result
+
+ def print_throughput_result(self, result):
+ # Print Test Summary
+ if 'nr_tput_result' in result:
+ self.log.info(
+ "----NR5G STATS-------NR5G STATS-------NR5G STATS---")
+ self.log.info(
+ "DL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['nr_tput_result']['total']['DL']['min_tput'],
+ result['nr_tput_result']['total']['DL']['average_tput'],
+ result['nr_tput_result']['total']['DL']['max_tput'],
+ result['nr_tput_result']['total']['DL']
+ ['theoretical_tput']))
+ self.log.info(
+ "UL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['nr_tput_result']['total']['UL']['min_tput'],
+ result['nr_tput_result']['total']['UL']['average_tput'],
+ result['nr_tput_result']['total']['UL']['max_tput'],
+ result['nr_tput_result']['total']['UL']
+ ['theoretical_tput']))
+ self.log.info("DL BLER: {:.2f}%\tUL BLER: {:.2f}%".format(
+ result['nr_bler_result']['total']['DL']['nack_ratio'] * 100,
+ result['nr_bler_result']['total']['UL']['nack_ratio'] * 100))
+ if 'lte_tput_result' in result:
+ self.log.info("----LTE STATS-------LTE STATS-------LTE STATS---")
+ self.log.info(
+ "DL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['lte_tput_result']['total']['DL']['min_tput'],
+ result['lte_tput_result']['total']['DL']['average_tput'],
+ result['lte_tput_result']['total']['DL']['max_tput'],
+ result['lte_tput_result']['total']['DL']
+ ['theoretical_tput']))
+ if self.testclass_params['lte_ul_mac_padding']:
+ self.log.info(
+ "UL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['lte_tput_result']['total']['UL']['min_tput'],
+ result['lte_tput_result']['total']['UL']
+ ['average_tput'],
+ result['lte_tput_result']['total']['UL']['max_tput'],
+ result['lte_tput_result']['total']['UL']
+ ['theoretical_tput']))
+ self.log.info("DL BLER: {:.2f}%\tUL BLER: {:.2f}%".format(
+ result['lte_bler_result']['total']['DL']['nack_ratio'] * 100,
+ result['lte_bler_result']['total']['UL']['nack_ratio'] * 100))
+ if self.testclass_params['traffic_type'] != 'PHY':
+ self.log.info("{} Tput: {:.2f} Mbps".format(
+ self.testclass_params['traffic_type'],
+ result['iperf_throughput']))
+
+ def setup_tester(self, testcase_params):
+ # Configure all cells
+ for cell_idx, cell in enumerate(
+ testcase_params['endc_combo_config']['cell_list']):
+ self.keysight_test_app.set_cell_duplex_mode(
+ cell['cell_type'], cell['cell_number'], cell['duplex_mode'])
+ self.keysight_test_app.set_cell_band(cell['cell_type'],
+ cell['cell_number'],
+ cell['band'])
+ self.keysight_test_app.set_cell_dl_power(
+ cell['cell_type'], cell['cell_number'],
+ testcase_params['cell_power_sweep'][cell_idx][0], 1)
+ if cell['cell_type'] == 'NR5G':
+ self.keysight_test_app.set_nr_subcarrier_spacing(
+ cell['cell_number'], cell['subcarrier_spacing'])
+ if 'channel' in cell:
+ self.keysight_test_app.set_cell_channel(
+ cell['cell_type'], cell['cell_number'], cell['channel'])
+ self.keysight_test_app.set_cell_bandwidth(cell['cell_type'],
+ cell['cell_number'],
+ cell['dl_bandwidth'])
+ self.keysight_test_app.set_cell_mimo_config(
+ cell['cell_type'], cell['cell_number'], 'DL',
+ cell['dl_mimo_config'])
+ if cell['cell_type'] == 'LTE':
+ self.keysight_test_app.set_lte_cell_transmission_mode(
+ cell['cell_number'], cell['transmission_mode'])
+ self.keysight_test_app.set_lte_control_region_size(
+ cell['cell_number'], 1)
+ if cell['ul_enabled'] and cell['cell_type'] == 'NR5G':
+ self.keysight_test_app.set_cell_mimo_config(
+ cell['cell_type'], cell['cell_number'], 'UL',
+ cell['ul_mimo_config'])
+
+ if testcase_params.get('force_contiguous_nr_channel', False):
+ self.keysight_test_app.toggle_contiguous_nr_channels(1)
+
+ if testcase_params['endc_combo_config']['lte_cell_count']:
+ self.keysight_test_app.set_lte_cell_mcs(
+ 'CELL1', testcase_params['lte_dl_mcs_table'],
+ testcase_params['lte_dl_mcs'],
+ testcase_params['lte_ul_mcs_table'],
+ testcase_params['lte_ul_mcs'])
+ self.keysight_test_app.set_lte_ul_mac_padding(
+ self.testclass_params['lte_ul_mac_padding'])
+
+ if testcase_params['endc_combo_config']['nr_cell_count']:
+ if 'schedule_scenario' in testcase_params:
+ self.keysight_test_app.set_nr_cell_schedule_scenario(
+ 'CELL1',
+ testcase_params['schedule_scenario'])
+ self.keysight_test_app.set_nr_ul_dft_precoding(
+ 'CELL1', testcase_params['transform_precoding'])
+ self.keysight_test_app.set_nr_cell_mcs(
+ 'CELL1', testcase_params['nr_dl_mcs'],
+ testcase_params['nr_ul_mcs'])
+ self.keysight_test_app.set_dl_carriers(
+ testcase_params['endc_combo_config']['nr_dl_carriers'])
+ self.keysight_test_app.set_ul_carriers(
+ testcase_params['endc_combo_config']['nr_ul_carriers'])
+
+ # Turn on LTE cells
+ for cell in testcase_params['endc_combo_config']['cell_list']:
+ if cell['cell_type'] == 'LTE' and not self.keysight_test_app.get_cell_state(
+ cell['cell_type'], cell['cell_number']):
+ self.log.info('Turning LTE Cell {} on.'.format(
+ cell['cell_number']))
+ self.keysight_test_app.set_cell_state(cell['cell_type'],
+ cell['cell_number'], 1)
+
+ # Activate LTE aggregation
+ if testcase_params['endc_combo_config']['lte_scc_list']:
+ self.keysight_test_app.apply_lte_carrier_agg(
+ testcase_params['endc_combo_config']['lte_scc_list'])
+
+ self.log.info('Waiting for LTE connections')
+ # Turn airplane mode off
+ num_apm_toggles = 5
+ for idx in range(num_apm_toggles):
+ self.log.info('Turning off airplane mode')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, False),
+ 'Can not turn off airplane mode.')
+ if self.keysight_test_app.wait_for_cell_status(
+ 'LTE', 'CELL1', 'CONN', 180):
+ break
+ elif idx < num_apm_toggles - 1:
+ self.log.info('Turning on airplane mode')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ time.sleep(MEDIUM_SLEEP)
+ else:
+ asserts.fail('DUT did not connect to LTE.')
+
+ if testcase_params['endc_combo_config']['nr_cell_count']:
+ self.keysight_test_app.apply_carrier_agg()
+ self.log.info('Waiting for 5G connection')
+ connected = self.keysight_test_app.wait_for_cell_status(
+ 'NR5G', testcase_params['endc_combo_config']['nr_cell_count'],
+ ['ACT', 'CONN'], 60)
+ if not connected:
+ asserts.fail('DUT did not connect to NR.')
+ time.sleep(SHORT_SLEEP)
+
+ def _test_throughput_bler(self, testcase_params):
+ """Test function to run cellular throughput and BLER measurements.
+
+ The function runs BLER/throughput measurement after configuring the
+ callbox and DUT. The test supports running PHY or TCP/UDP layer traffic
+ in a variety of band/carrier/mcs/etc configurations.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ Returns:
+ result: dict containing throughput results and meta data
+ """
+ # Prepare results dicts
+ testcase_params = self.compile_test_params(testcase_params)
+ testcase_results = collections.OrderedDict()
+ testcase_results['testcase_params'] = testcase_params
+ testcase_results['results'] = []
+
+ # Setup tester and wait for DUT to connect
+ self.setup_tester(testcase_params)
+
+ # Run throughput test loop
+ stop_counter = 0
+ if testcase_params['endc_combo_config']['nr_cell_count']:
+ self.keysight_test_app.select_display_tab('NR5G', 1, 'BTHR',
+ 'OTAGRAPH')
+ else:
+ self.keysight_test_app.select_display_tab('LTE', 1, 'BTHR',
+ 'OTAGRAPH')
+ for power_idx in range(len(testcase_params['cell_power_sweep'][0])):
+ result = collections.OrderedDict()
+ # Set DL cell power
+ result['cell_power'] = []
+ for cell_idx, cell in enumerate(
+ testcase_params['endc_combo_config']['cell_list']):
+ current_cell_power = testcase_params['cell_power_sweep'][
+ cell_idx][power_idx]
+ result['cell_power'].append(current_cell_power)
+ self.keysight_test_app.set_cell_dl_power(
+ cell['cell_type'], cell['cell_number'], current_cell_power,
+ 1)
+
+ # Start BLER and throughput measurements
+ result = self.run_single_throughput_measurement(testcase_params)
+ testcase_results['results'].append(result)
+
+ self.print_throughput_result(result)
+
+ if (('lte_bler_result' in result
+ and result['lte_bler_result']['total']['DL']['nack_ratio'] *
+ 100 > 99) or
+ ('nr_bler_result' in result
+ and result['nr_bler_result']['total']['DL']['nack_ratio'] *
+ 100 > 99)):
+ stop_counter = stop_counter + 1
+ else:
+ stop_counter = 0
+ if stop_counter == STOP_COUNTER_LIMIT:
+ break
+
+ # Save results
+ self.testclass_results[self.current_test_name] = testcase_results
diff --git a/acts_tests/acts_contrib/test_utils/cellular/performance/__init__.py b/acts_tests/acts_contrib/test_utils/cellular/performance/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/performance/__init__.py
diff --git a/acts_tests/acts_contrib/test_utils/cellular/performance/cellular_performance_test_utils.py b/acts_tests/acts_contrib/test_utils/cellular/performance/cellular_performance_test_utils.py
new file mode 100644
index 0000000..4aaff91
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/performance/cellular_performance_test_utils.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import logging
+import os
+import time
+
+PCC_PRESET_MAPPING = {
+ 'N257': {
+ 'low': 2054999,
+ 'mid': 2079165,
+ 'high': 2090832
+ },
+ 'N258': {
+ 'low': 2017499,
+ 'mid': 2043749,
+ 'high': 2057499
+ },
+ 'N260': {
+ 'low': 2229999,
+ 'mid': 2254165,
+ 'high': 2265832
+ },
+ 'N261': {
+ 'low': 2071667
+ }
+}
+
+DUPLEX_MODE_TO_BAND_MAPPING = {
+ 'LTE': {
+ 'FDD': [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 85, 252, 255
+ ],
+ 'TDD': [
+ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46, 47, 48,
+ 50, 51, 53
+ ]
+ },
+ 'NR5G': {
+ 'FDD': [
+ 'N1', 'N2', 'N3', 'N5', 'N7', 'N8', 'N12', 'N13', 'N14', 'N18',
+ 'N20', 'N25', 'N26', 'N28', 'N30', 'N65', 'N66', 'N70', 'N71',
+ 'N74'
+ ],
+ 'TDD': [
+ 'N34', 'N38', 'N39', 'N40', 'N41', 'N48', 'N50', 'N51', 'N53',
+ 'N77', 'N78', 'N79', 'N90', 'N257', 'N258', 'N259', 'N260', 'N261'
+ ]
+ },
+}
+
+
+def extract_test_id(testcase_params, id_fields):
+ test_id = collections.OrderedDict(
+ (param, testcase_params[param]) for param in id_fields)
+ return test_id
+
+
+def start_pixel_logger(ad):
+ """Function to start pixel logger with default log mask.
+
+ Args:
+ ad: android device on which to start logger
+ """
+
+ try:
+ ad.adb.shell(
+ 'rm -R /storage/emulated/0/Android/data/com.android.pixellogger/files/logs/logs/'
+ )
+ except:
+ pass
+ ad.adb.shell(
+ 'am startservice -a com.android.pixellogger.service.logging.LoggingService.ACTION_START_LOGGING'
+ )
+
+
+def stop_pixel_logger(ad, log_path, tag=None):
+ """Function to stop pixel logger and retrieve logs
+
+ Args:
+ ad: android device on which to start logger
+ log_path: location of saved logs
+ """
+ ad.adb.shell(
+ 'am startservice -a com.android.pixellogger.service.logging.LoggingService.ACTION_STOP_LOGGING'
+ )
+ logging.info('Waiting for Pixel log file')
+ file_name = None
+ file_size = 0
+ previous_file_size = 0
+ for idx in range(600):
+ try:
+ file = ad.adb.shell(
+ 'ls -l /storage/emulated/0/Android/data/com.android.pixellogger/files/logs/logs/'
+ ).split(' ')
+ file_name = file[-1]
+ file_size = file[-4]
+ except:
+ file_name = None
+ file_size = 0
+ if file_name and file_size == previous_file_size:
+ logging.info('Log file found after {}s.'.format(idx))
+ break
+ else:
+ previous_file_size = file_size
+ time.sleep(1)
+ try:
+ local_file_name = '{}_{}'.format(file_name, tag) if tag else file_name
+ local_path = os.path.join(log_path, local_file_name)
+ ad.pull_files(
+ '/storage/emulated/0/Android/data/com.android.pixellogger/files/logs/logs/{}'
+ .format(file_name), log_path)
+ return local_path
+ except:
+ logging.error('Could not pull pixel logs.')
+
+
+def log_system_power_metrics(ad, verbose=1):
+ # Log temperature sensors
+ if verbose:
+ temp_sensors = ad.adb.shell(
+ 'ls -1 /dev/thermal/tz-by-name/').splitlines()
+ else:
+ temp_sensors = ['BIG', 'battery', 'quiet_therm', 'usb_pwr_therm']
+ temp_measurements = collections.OrderedDict()
+ for sensor in temp_sensors:
+ try:
+ temp_measurements[sensor] = ad.adb.shell(
+ 'cat /dev/thermal/tz-by-name/{}/temp'.format(sensor))
+ except:
+ temp_measurements[sensor] = float('nan')
+ logging.debug('Temperature sensor readings: {}'.format(temp_measurements))
+
+ # Log mitigation items
+ if verbose:
+ mitigation_points = [
+ "batoilo",
+ "ocp_cpu1",
+ "ocp_cpu2",
+ "ocp_gpu",
+ "ocp_tpu",
+ "smpl_warn",
+ "soft_ocp_cpu1",
+ "soft_ocp_cpu2",
+ "soft_ocp_gpu",
+ "soft_ocp_tpu",
+ "vdroop1",
+ "vdroop2",
+ ]
+ else:
+ mitigation_points = [
+ "batoilo",
+ "smpl_warn",
+ "vdroop1",
+ "vdroop2",
+ ]
+
+ parameters_f = ['count', 'capacity', 'timestamp', 'voltage']
+ parameters_v = ['count', 'cap', 'time', 'volt']
+ mitigation_measurements = collections.OrderedDict()
+ for mp in mitigation_points:
+ mitigation_measurements[mp] = collections.OrderedDict()
+ for par_f, par_v in zip(parameters_f, parameters_v):
+ mitigation_measurements[mp][par_v] = ad.adb.shell(
+ 'cat /sys/devices/virtual/pmic/mitigation/last_triggered_{}/{}_{}'
+ .format(par_f, mp, par_v))
+ logging.debug('Mitigation readings: {}'.format(mitigation_measurements))
+
+ # Log power meter items
+ power_meter_measurements = collections.OrderedDict()
+ for device in ['device0', 'device1']:
+ power_str = ad.adb.shell(
+ 'cat /sys/bus/iio/devices/iio:{}/lpf_power'.format(
+ device)).splitlines()
+ power_meter_measurements[device] = collections.OrderedDict()
+ for line in power_str:
+ if line.startswith('CH'):
+ try:
+ line_split = line.split(', ')
+ power_meter_measurements[device][line_split[0]] = int(
+ line_split[1])
+ except (IndexError, ValueError):
+ continue
+ elif line.startswith('t='):
+ try:
+ power_meter_measurements[device]['t_pmeter'] = int(
+ line[2:])
+ except (IndexError, ValueError):
+ continue
+ else:
+ continue
+ logging.debug(
+ 'Power Meter readings: {}'.format(power_meter_measurements))
+
+ # Log battery items
+ if verbose:
+ battery_parameters = [
+ "act_impedance", "capacity", "charge_counter", "charge_full",
+ "charge_full_design", "current_avg", "current_now",
+ "cycle_count", "health", "offmode_charger", "present",
+ "rc_switch_enable", "resistance", "status", "temp",
+ "voltage_avg", "voltage_now", "voltage_ocv"
+ ]
+ else:
+ battery_parameters = [
+ "capacity", "current_avg", "current_now", "voltage_avg",
+ "voltage_now", "voltage_ocv"
+ ]
+
+ battery_meaurements = collections.OrderedDict()
+ for par in battery_parameters:
+ battery_meaurements['bat_{}'.format(par)] = ad.adb.shell(
+ 'cat /sys/class/power_supply/maxfg/{}'.format(par))
+ logging.debug('Battery readings: {}'.format(battery_meaurements))
diff --git a/acts_tests/acts_contrib/test_utils/cellular/performance/shannon_log_parser.py b/acts_tests/acts_contrib/test_utils/cellular/performance/shannon_log_parser.py
new file mode 100644
index 0000000..89c2adf
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/cellular/performance/shannon_log_parser.py
@@ -0,0 +1,808 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 datetime
+import gzip
+import itertools
+import logging
+import numpy
+import os
+import re
+import shutil
+import subprocess
+import zipfile
+from acts import context
+from pathlib import Path
+
+_DIGITS_REGEX = re.compile(r'-?\d+')
+_TX_PWR_MAX = 100
+_TX_PWR_MIN = -100
+
+
+class LastNrPower:
+ last_time = 0
+ last_pwr = 0
+
+
+class LastLteValue:
+ last_time = 0
+ last_pwr = 0
+
+
+def _string_to_float(input_string):
+ """Convert string to float value."""
+ try:
+ tmp = float(input_string)
+ except ValueError:
+ print(input_string)
+ tmp = float('nan')
+ return tmp
+
+
+def to_time(time_str):
+ """Convert time string to data time."""
+ return datetime.datetime.strptime(time_str, '%H:%M:%S.%f')
+
+
+def to_time_sec(time_str, start_time):
+ """"Converts time string to seconds elapsed since start time."""
+ return (to_time(time_str) - start_time).total_seconds()
+
+
+class LogParser(object):
+ """Base class to parse log csv files."""
+
+ def __init__(self):
+ self.timestamp_col = -1
+ self.message_col = -1
+ self.start_time = None
+
+ # Dictionary of {log_item_header: log_time_parser} elements
+ self.PARSER_INFO = {
+ r'###[AS] RSRP[': self._parse_lte_rsrp,
+ r'|CC0| PCell RSRP ': self._parse_lte_rsrp2,
+ r'|CC0 Mx0 Sc0| PCell RSRP ': self._parse_lte_rsrp2,
+ r'LT12 PUSCH_Power': self._parse_lte_power,
+ r'UL_PWR(PUSCH)=>pwr_val:': self._parse_lte_power,
+ r'[BM]SSB_RSRP(1)': self._parse_nr_rsrp,
+ r'[BM]SSB_RSRP(0)': self._parse_nr_rsrp,
+ r'###[AS] CurAnt': self._parse_nr_rsrp2,
+ r'[PHY] RF module(': self._parse_fr2_rsrp,
+ #r'[RF] PD : CC0 (monitoring) target_pwr': _parse_fr2_power,
+ #r'[NrPhyTxScheduler][PuschCalcPower] Po_nominal_pusch': _parse_nr_power,
+ r'[NrPhyTxPuschScheduler][PuschCalcPower] Po_nominal_pusch':
+ self._parse_fr2_power,
+ r'[RF NR SUB6] PD : CC0 (monitoring) target_pwr':
+ self._parse_nr_power2,
+ r'[RF NR SUB6] PD : CC1 (monitoring) target_pwr':
+ self._parse_nr_power2,
+ r'[AS] RFAPI_ChangeAntennaSwitch': self._parse_lte_ant_sel,
+ r'[AS] Ant switching': self._parse_lte_ant_sel2,
+ r'###[AS] Select Antenna': self._parse_nr_ant_sel,
+ r'###[AS] CurAnt(': self._parse_nr_ant_sel2,
+ r'[SAR][RESTORE]': self._parse_sar_mode,
+ r'[SAR][NORMAL]': self._parse_sar_mode,
+ r'[SAR][LIMITED-TAPC]': self._parse_tapc_sar_mode,
+ r'###[TAS] [0] ProcessRestoreStage:: [RESTORE]':
+ self._parse_nr_sar_mode,
+ r'###[TAS] [0] ProcessNormalStage:: [NORMAL]':
+ self._parse_nr_sar_mode,
+ r'|CC0| UL Power : PRACH ': self._parse_lte_avg_power,
+ r'activeStackId=0\, [Monitor] txPower ': self._parse_wcdma_power,
+ r'[SAR][DYNAMIC] EN-DC(2) UsedAvgSarLTE': self._parse_sar_values,
+ #r'[SAR][DYNAMIC] UsedAvgSarLTE_100s': self._parse_sar_values2,
+ r'[SAR][DYNAMIC] EN-DC(0) UsedAvgSarLTE':
+ self._parse_lte_sar_values,
+ r'###[TAS] [0] CalcGain:: TotalUsedSar': self._parse_nr_sar_values,
+ r'[SAR][DYNAMIC] IsLTEOn(1) IsNROn(0) ':
+ self._parse_lte_sar_values,
+ r'[SAR][DYNAMIC] IsLTEOn(1) IsNROn(1) ': self._parse_sar_values,
+ r'[MAIN][VolteStatusInd] Volte status ': self._parse_volte_status,
+ r'[PHY] CC0 SLP : dlGrantRatio(3)/ulGrantRatio(3)/RbRatio(3)':
+ self._parse_df_value,
+ r'CC0 AVG: CELLGROUP(0) DCI(D/U):': self._parse_df_value,
+ r'[OL-AIT] band': self._parse_ul_mimo,
+ }
+
+ self.SAR_MODES = [
+ 'none', 'MIN', 'SAV_1', 'SAV_2', 'MAIN', 'PRE_SAV', 'LIMITED-TAPC',
+ 'MAX', 'none'
+ ]
+ self.SAR_MODES_DESC = [
+ '', 'Minimum', 'Slope Saving1', 'Slope Saving2', 'Maintenance',
+ 'Pre-Save', 'Limited TAPC', 'Maximum', ''
+ ]
+
+ def parse_header(self, header_line):
+ header = header_line.split(',')
+ try:
+ self.timestamp_col = header.index('PC Time')
+ self.message_col = header.index('Message')
+ except ValueError:
+ print('Error: PC Time and Message fields are not present')
+ try:
+ self.core_id_col = header.index('Core ID')
+ except:
+ self.core_id_col = self.timestamp_col
+
+ def parse_log(self, log_file, gap_options=0):
+ """Extract required data from the exported CSV file."""
+
+ log_data = LogData()
+ log_data.gap_options = gap_options
+ # Fr-1 as default
+ fr_id = 0
+
+ with open(log_file, 'r') as file:
+ # Read header line
+ header = file.readline()
+ try:
+ self.parse_header(header)
+ except:
+ print('Could not parse header')
+ return log_data
+
+ # Use first message for start time
+ line = file.readline()
+ print(line)
+ line_data = line[1:-2].split('","')
+ if len(line_data) < self.message_col:
+ print('Error: Empty exported file')
+ return log_data
+
+ start_time = to_time(line_data[self.timestamp_col])
+
+ print('Parsing log file ... ', end='', flush=True)
+ for line in file:
+ line_data = line[1:-2].split('","')
+ if len(line_data) < self.message_col + 1:
+ continue
+
+ message = line_data[self.message_col]
+ if "frIdx 1 " in message:
+ fr_id = 1
+ elif "frIdx 0 " in message:
+ fr_id = 0
+ for line_prefix, line_parser in self.PARSER_INFO.items():
+ if message.startswith(line_prefix):
+ timestamp = to_time_sec(line_data[self.timestamp_col],
+ start_time)
+ if self.core_id_col == self.timestamp_col:
+ line_parser(timestamp, message[len(line_prefix):],
+ 'L1', log_data, fr_id)
+ else:
+ if " CC1 " in message:
+ line_parser(timestamp,
+ message[len(line_prefix):], 'L2',
+ log_data, fr_id)
+ else:
+ line_parser(timestamp,
+ message[len(line_prefix):],
+ line_data[self.core_id_col],
+ log_data, fr_id)
+ break
+
+ if log_data.nr.tx_pwr_time:
+ if log_data.nr.tx_pwr_time[1] > log_data.nr.tx_pwr_time[0] + 50:
+ log_data.nr.tx_pwr_time = log_data.nr.tx_pwr_time[1:]
+ log_data.nr.tx_pwr = log_data.nr.tx_pwr[1:]
+
+ self._find_cur_ant(log_data.lte)
+ self._find_cur_ant(log_data.nr)
+ return log_data
+
+ def get_file_start_time(self, log_file):
+ # Fr-1 as default
+
+ with open(log_file, 'r') as file:
+ # Read header line
+ header = file.readline()
+ try:
+ self.parse_header(header)
+ except:
+ print('Could not parse header')
+ return None
+
+ # Use first message for start time
+ line = file.readline()
+ line_data = line[1:-2].split('","')
+ if len(line_data) < self.message_col:
+ print('Error: Empty exported file')
+ return None
+
+ start_time = to_time(line_data[self.timestamp_col])
+ return start_time
+
+ def set_start_time(self, line):
+ """Set start time of logs to the time in the line."""
+ if len(line) == 0:
+ print("Empty Line")
+ return
+ line_data = line[1:-2].split('","')
+ self.start_time = to_time(line_data[self.timestamp_col])
+
+ def get_message(self, line):
+ """Returns message and timestamp for the line."""
+ line_data = line[1:-2].split('","')
+ if len(line_data) < self.message_col + 1:
+ return None
+
+ self.line_data = line_data
+ return line_data[self.message_col]
+
+ def get_time(self, line):
+ """Convert time string to time in seconds from the start time."""
+ line_data = line[1:-2].split('","')
+ if len(line_data) < self.timestamp_col + 1:
+ return 0
+
+ return to_time_sec(line_data[self.timestamp_col], self.start_time)
+
+ def _feed_nr_power(self, timestamp, tx_pwr, option, lte_nr, window,
+ default, interval):
+ if option < 101 and LastNrPower.last_time > 0 and timestamp - LastNrPower.last_time > interval:
+ #print ('window=',window, ' interval=',interval, ' gap=',timestamp-LastNrPower.last_time)
+ ti = LastNrPower.last_time
+ while ti < timestamp:
+ ti += (timestamp - LastNrPower.last_time) / window
+ lte_nr.tx_pwr_time.append(ti)
+ if option == 0:
+ lte_nr.tx_pwr.append(tx_pwr / default)
+ elif option == 1:
+ lte_nr.tx_pwr.append(LastNrPower.last_pwr)
+ elif option == 2:
+ lte_nr.tx_pwr.append((tx_pwr + LastNrPower.last_pwr) / 2)
+ elif option == 3:
+ lte_nr.tx_pwr.append(0)
+ else:
+ lte_nr.tx_pwr.append(option)
+ else:
+ lte_nr.tx_pwr_time.append(timestamp)
+ lte_nr.tx_pwr.append(tx_pwr)
+ LastNrPower.last_time = timestamp
+ LastNrPower.last_pwr = tx_pwr
+
+ def _feed_lte_power(self, timestamp, tx_pwr, log_data, lte_nr, window,
+ default, interval):
+ if log_data.gap_options <= 100 and LastLteValue.last_time > 0 and timestamp - LastLteValue.last_time > interval:
+ #print ('window=',window, ' interval=',interval, ' gap=',timestamp-LastLteValue.last_time)
+ ti = LastLteValue.last_time
+ while ti < timestamp:
+ ti += (timestamp - LastLteValue.last_time) / window
+ lte_nr.tx_pwr_time.append(ti)
+ if log_data.gap_options == 0:
+ lte_nr.tx_pwr.append(tx_pwr / default)
+ elif log_data.gap_options == 1:
+ lte_nr.tx_pwr.append(LastLteValue.last_pwr)
+ elif log_data.gap_options == 2:
+ lte_nr.tx_pwr.append((tx_pwr + LastLteValue.last_pwr) / 2)
+ elif log_data.gap_options == 3:
+ lte_nr.tx_pwr.append(0)
+ else:
+ lte_nr.tx_pwr.append(log_data.gap_options)
+ else:
+ lte_nr.tx_pwr_time.append(timestamp)
+ lte_nr.tx_pwr.append(tx_pwr)
+ LastLteValue.last_time = timestamp
+ LastLteValue.last_pwr = tx_pwr
+
+ def _parse_lte_power(self, timestamp, message, core_id, log_data, fr_id):
+ match = re.search(r'-?\d+', message)
+ if match:
+ tx_pwr = _string_to_float(match.group())
+ if _TX_PWR_MIN < tx_pwr < _TX_PWR_MAX:
+ self._feed_lte_power(timestamp, tx_pwr, log_data, log_data.lte,
+ 20, 1, 1)
+
+ def _parse_lte_rsrp(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ rsrp0 = _string_to_float(data[0]) / 100.0
+ rsrp1 = _string_to_float(data[1]) / 100.0
+ if rsrp0 != 0.0 and rsrp1 != 0.0:
+ log_data.lte.rsrp_time.append(timestamp)
+ log_data.lte.rsrp_rx0.append(rsrp0)
+ log_data.lte.rsrp_rx1.append(rsrp1)
+
+ def _parse_lte_rsrp2(self, timestamp, message, core_id, log_data, fr_id):
+ m = re.search('^\[ ?-?\d+ \((.*?)\)', message)
+ if not m:
+ return
+ data = _DIGITS_REGEX.findall(m.group(1))
+ if len(data) < 2:
+ return
+ rsrp0 = _string_to_float(data[0])
+ rsrp1 = _string_to_float(data[1])
+ if rsrp0 != 0.0 and rsrp1 != 0.0:
+ log_data.lte.rsrp2_time.append(timestamp)
+ log_data.lte.rsrp2_rx0.append(rsrp0)
+ log_data.lte.rsrp2_rx1.append(rsrp1)
+
+ def _parse_nr_rsrp(self, timestamp, message, core_id, log_data, fr_id):
+ index = message.find('rx0/rx1/rx2/rx3')
+ if index != -1:
+ data = _DIGITS_REGEX.findall(message[index:])
+ log_data.nr.rsrp_time.append(timestamp)
+ log_data.nr.rsrp_rx0.append(_string_to_float(data[4]) / 100)
+ log_data.nr.rsrp_rx1.append(_string_to_float(data[5]) / 100)
+
+ def _parse_nr_rsrp2(self, timestamp, message, core_id, log_data, fr_id):
+ index = message.find('Rsrp')
+ if index != -1:
+ data = _DIGITS_REGEX.findall(message[index:])
+ log_data.nr.rsrp2_time.append(timestamp)
+ log_data.nr.rsrp2_rx0.append(_string_to_float(data[0]) / 100)
+ log_data.nr.rsrp2_rx1.append(_string_to_float(data[1]) / 100)
+
+ def _parse_fr2_rsrp(self, timestamp, message, core_id, log_data, fr_id):
+ index = message.find('rsrp')
+ data = _DIGITS_REGEX.search(message)
+ module_index = _string_to_float(data.group(0))
+ data = _DIGITS_REGEX.findall(message[index:])
+ rsrp = _string_to_float(data[0])
+
+ if rsrp == 0:
+ return
+ if module_index == 0:
+ log_data.fr2.rsrp0_time.append(timestamp)
+ log_data.fr2.rsrp0.append(rsrp if rsrp < 999 else float('nan'))
+ elif module_index == 1:
+ log_data.fr2.rsrp1_time.append(timestamp)
+ log_data.fr2.rsrp1.append(rsrp if rsrp < 999 else float('nan'))
+
+ def _parse_fr2_power(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ tx_pwr = _string_to_float(data[-1]) / 10
+ if _TX_PWR_MIN < tx_pwr < _TX_PWR_MAX:
+ log_data.fr2.tx_pwr_time.append(timestamp)
+ log_data.fr2.tx_pwr.append(tx_pwr)
+
+ def _parse_nr_power(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ tx_pwr = _string_to_float(data[-1]) / 10
+ if _TX_PWR_MIN < tx_pwr < _TX_PWR_MAX:
+ if core_id == 'L2':
+ self._feed_nr_power(timestamp, tx_pwr, log_data.gap_options,
+ log_data.nr2, 5, 1, 1)
+ else:
+ self._feed_nr_power(timestamp, tx_pwr, log_data.gap_options,
+ log_data.nr, 5, 1, 1)
+
+ def _parse_nr_power2(self, timestamp, message, core_id, log_data, fr_id):
+ if fr_id != 0:
+ return
+ data = _DIGITS_REGEX.findall(message)
+ tx_pwr = _string_to_float(data[0]) / 10
+ if _TX_PWR_MIN < tx_pwr < _TX_PWR_MAX:
+ if core_id == 'L2':
+ self._feed_nr_power(timestamp, tx_pwr, log_data.gap_options,
+ log_data.nr2, 5, 1, 1)
+ else:
+ self._feed_nr_power(timestamp, tx_pwr, log_data.gap_options,
+ log_data.nr, 5, 1, 1)
+
+ def _parse_lte_ant_sel(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ new_ant = _string_to_float(data[1])
+ old_ant = _string_to_float(data[2])
+ log_data.lte.ant_sel_time.append(timestamp)
+ log_data.lte.ant_sel_old.append(old_ant)
+ log_data.lte.ant_sel_new.append(new_ant)
+
+ def _parse_lte_ant_sel2(self, timestamp, message, core_id, log_data,
+ fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ if data[0] == '0':
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(0)
+ elif data[0] == '1':
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(1)
+ elif data[0] == '10':
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(1)
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(0)
+ elif data[0] == '01':
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(0)
+ log_data.lte.cur_ant_time.append(timestamp)
+ log_data.lte.cur_ant.append(1)
+
+ def _parse_nr_ant_sel(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.nr.ant_sel_time.append(timestamp)
+ log_data.nr.ant_sel_new.append(_string_to_float(data[1]))
+ log_data.nr.ant_sel_old.append(_string_to_float(data[0]))
+
+ def _parse_nr_ant_sel2(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.nr.ant_sel_time.append(timestamp)
+ sel_ant = _string_to_float(data[0])
+ log_data.nr.ant_sel_new.append(sel_ant)
+ if log_data.nr.ant_sel_new:
+ log_data.nr.ant_sel_old.append(log_data.nr.ant_sel_new[-1])
+
+ def _parse_sar_mode(self, timestamp, message, core_id, log_data, fr_id):
+ sar_mode = len(self.SAR_MODES) - 1
+ for i, mode in enumerate(self.SAR_MODES):
+ if message.startswith('[' + mode + ']'):
+ sar_mode = i
+ log_data.lte.sar_mode_time.append(timestamp)
+ log_data.lte.sar_mode.append(sar_mode)
+
+ def _parse_tapc_sar_mode(self, timestamp, message, core_id, log_data,
+ fr_id):
+ log_data.lte.sar_mode_time.append(timestamp)
+ log_data.lte.sar_mode.append(self.SAR_MODES.index('LIMITED-TAPC'))
+
+ def _parse_nr_sar_mode(self, timestamp, message, core_id, log_data, fr_id):
+ sar_mode = len(self.SAR_MODES) - 1
+ for i, mode in enumerate(self.SAR_MODES):
+ if message.startswith('[' + mode + ']'):
+ sar_mode = i
+
+ log_data.nr.sar_mode_time.append(timestamp)
+ log_data.nr.sar_mode.append(sar_mode)
+
+ def _parse_lte_avg_power(self, timestamp, message, core_id, log_data,
+ fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ tx_pwr = _string_to_float(data[2])
+ if _TX_PWR_MIN < tx_pwr < _TX_PWR_MAX:
+ log_data.lte.tx_avg_pwr_time.append(timestamp)
+ log_data.lte.tx_avg_pwr.append(tx_pwr)
+
+ def _parse_wcdma_power(self, timestamp, message, core_id, log_data, fr_id):
+ match = re.search(r'-?\d+', message)
+ if match:
+ tx_pwr = _string_to_float(match.group()) / 10
+ if tx_pwr < _TX_PWR_MAX and tx_pwr > _TX_PWR_MIN:
+ log_data.wcdma.tx_pwr_time.append(timestamp)
+ log_data.wcdma.tx_pwr.append(tx_pwr)
+
+ def _parse_sar_values(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.endc_sar_time.append(timestamp)
+ log_data.endc_sar_lte.append(_string_to_float(data[0]) / 1000.0)
+ log_data.endc_sar_nr.append(_string_to_float(data[1]) / 1000.0)
+
+ def _parse_sar_values2(self, timestamp, message, core_id, log_data, fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.endc_sar_time.append(timestamp)
+ log_data.endc_sar_lte.append(_string_to_float(data[-3]) / 1000.0)
+ log_data.endc_sar_nr.append(_string_to_float(data[-1]) / 1000.0)
+
+ def _parse_lte_sar_values(self, timestamp, message, core_id, log_data,
+ fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.lte_sar_time.append(timestamp)
+ log_data.lte_sar.append(_string_to_float(data[0]) / 1000.0)
+
+ def _parse_nr_sar_values(self, timestamp, message, core_id, log_data,
+ fr_id):
+ data = _DIGITS_REGEX.findall(message)
+ log_data.nr_sar_time.append(timestamp)
+ log_data.nr_sar.append(_string_to_float(data[0]) / 1000.0)
+
+ def _parse_df_value(self, timestamp, message, core_id, log_data, fr_id):
+ match = re.search(r' \d+', message)
+ if match:
+ nr_df = _string_to_float(match.group())
+ log_data.nr.df = (nr_df / 1000 % 1000) / 100
+ log_data.nr.duty_cycle_time.append(timestamp)
+ log_data.nr.duty_cycle.append(log_data.nr.df * 100)
+ else:
+ match = re.search(r'\d+\\,\d+', message)
+ if match:
+ lte_df = match.group(0).split(",")
+ log_data.lte.df = _string_to_float(lte_df[1]) / 100
+ log_data.lte.duty_cycle_time.append(timestamp)
+ log_data.lte.duty_cycle.append(log_data.nr.df * 100)
+
+ def _parse_volte_status(self, timestamp, message, core_id, log_data,
+ fr_id):
+ if message.startswith('[0 -> 1]'):
+ log_data.volte_time.append(timestamp)
+ log_data.volte_status.append(1)
+ elif message.startswith('[3 -> 0]'):
+ log_data.volte_time.append(timestamp)
+ log_data.volte_status.append(0)
+
+ def _parse_ul_mimo(self, timestamp, message, core_id, log_data, fr_id):
+ match = re.search(r'UL-MIMO', message)
+ if match:
+ log_data.ul_mimo = 1
+
+ def _find_cur_ant(self, log_data):
+ """Interpolate antenna selection from antenna switching data."""
+ if not log_data.cur_ant_time and log_data.ant_sel_time:
+ if log_data.rsrp_time:
+ start_time = log_data.rsrp_time[0]
+ end_time = log_data.rsrp_time[-1]
+ elif log_data.tx_pwr:
+ start_time = log_data.tx_pwr_time[0]
+ end_time = log_data.tx_pwr_time[-1]
+ else:
+ start_time = log_data.ant_sel_time[0]
+ end_time = log_data.ant_sel_time[-1]
+
+ [sel_time,
+ sel_ant] = self.get_ant_selection(log_data.ant_sel_time,
+ log_data.ant_sel_old,
+ log_data.ant_sel_new,
+ start_time, end_time)
+
+ log_data.cur_ant_time = sel_time
+ log_data.cur_ant = sel_ant
+
+ def get_ant_selection(self, config_time, old_antenna_config,
+ new_antenna_config, start_time, end_time):
+ """Generate antenna selection data from antenna switching information."""
+ sel_time = []
+ sel_ant = []
+ if not config_time:
+ return [sel_time, sel_ant]
+
+ # Add data point for the start time
+ if config_time[0] > start_time:
+ sel_time = [start_time]
+ sel_ant = [old_antenna_config[0]]
+
+ # Add one data point before the switch and one data point after the switch.
+ for i in range(len(config_time)):
+ if not (i > 0
+ and old_antenna_config[i - 1] == old_antenna_config[i]
+ and new_antenna_config[i - 1] == new_antenna_config[i]):
+ sel_time.append(config_time[i])
+ sel_ant.append(old_antenna_config[i])
+ sel_time.append(config_time[i])
+ sel_ant.append(new_antenna_config[i])
+
+ # Add data point for the end time
+ if end_time > config_time[-1]:
+ sel_time.append(end_time)
+ sel_ant.append(new_antenna_config[-1])
+
+ return [sel_time, sel_ant]
+
+
+class RatLogData:
+ """Log data structure for each RAT (LTE/NR)."""
+
+ def __init__(self, label):
+
+ self.label = label
+
+ self.rsrp_time = [] # RSRP time
+ self.rsrp_rx0 = [] # RSRP for receive antenna 0
+ self.rsrp_rx1 = [] # RSRP for receive antenna 1
+
+ # second set of RSRP logs
+ self.rsrp2_time = [] # RSRP time
+ self.rsrp2_rx0 = [] # RSRP for receive antenna 0
+ self.rsrp2_rx1 = [] # RSRP for receive antenna 1
+
+ self.ant_sel_time = [] # Antenna selection/switch time
+ self.ant_sel_old = [] # Previous antenna selection
+ self.ant_sel_new = [] # New antenna selection
+
+ self.cur_ant_time = [] # Antenna selection/switch time
+ self.cur_ant = [] # Previous antenna selection
+
+ self.tx_pwr_time = [] # TX power time
+ self.tx_pwr = [] # TX power
+
+ self.tx_avg_pwr_time = []
+ self.tx_avg_pwr = []
+
+ self.sar_mode = []
+ self.sar_mode_time = []
+
+ self.df = 1.0 # Duty factor for UL transmission
+ self.duty_cycle = [] # Duty factors for UL transmission
+ self.duty_cycle_time = [] # Duty factors for UL transmission
+ self.initial_power = 0
+ self.sar_limit_dbm = None
+ self.avg_window_size = 100
+
+
+class LogData:
+ """Log data structure."""
+
+ def __init__(self):
+ self.lte = RatLogData('LTE')
+ self.lte.avg_window_size = 100
+
+ self.nr = RatLogData('NR CC0')
+ self.nr.avg_window_size = 100
+
+ # NR 2nd CC
+ self.nr2 = RatLogData('NR CC1')
+ self.nr2.avg_window_size = 100
+
+ self.wcdma = RatLogData('WCDMA')
+
+ self.fr2 = RatLogData('FR2')
+ self.fr2.rsrp0_time = []
+ self.fr2.rsrp0 = []
+ self.fr2.rsrp1_time = []
+ self.fr2.rsrp1 = []
+ self.fr2.avg_window_size = 4
+
+ self.lte_sar_time = []
+ self.lte_sar = []
+
+ self.nr_sar_time = []
+ self.nr_sar = []
+
+ self.endc_sar_time = []
+ self.endc_sar_lte = []
+ self.endc_sar_nr = []
+
+ self.volte_time = []
+ self.volte_status = []
+
+ # Options to handle data gaps
+ self.gap_options = 0
+
+ self.ul_mimo = 0 # Is UL_MIMO
+
+
+class ShannonLogger(object):
+
+ def __init__(self, dut=None, modem_bin=None, filter_file_path=None):
+ self.dm_app = shutil.which(r'DMConsole')
+ self.dut = dut
+ if self.dut:
+ self.modem_bin = self.pull_modem_file()
+ elif modem_bin:
+ self.modem_bin = modem_bin
+ else:
+ raise (RuntimeError,
+ 'ShannonLogger requires AndroidDevice or modem binary.')
+ self.filter_file = filter_file_path
+
+ def pull_modem_file(self):
+ local_modem_path = os.path.join(
+ context.get_current_context().get_full_output_path(), 'modem_bin')
+ os.makedirs(local_modem_path, exist_ok=True)
+ try:
+ self.dut.pull_files(
+ '/mnt/vendor/modem_img/images/default/modem.bin',
+ local_modem_path)
+ modem_bin_file = os.path.join(local_modem_path, 'modem.bin')
+ except:
+ self.dut.pull_files(
+ '/mnt/vendor/modem_img/images/default/modem.bin.gz',
+ local_modem_path)
+ modem_zip_file = os.path.join(local_modem_path, 'modem.bin.gz')
+ modem_bin_file = modem_zip_file[:-3]
+ with open(modem_zip_file, 'rb') as in_file:
+ with open(modem_bin_file, 'wb') as out_file:
+ file_content = gzip.decompress(in_file.read())
+ out_file.write(file_content)
+ return modem_bin_file
+
+ def _unzip_log(self, log_zip_file, in_place=1):
+ log_zip_file = Path(log_zip_file)
+ with zipfile.ZipFile(log_zip_file, 'r') as zip_ref:
+ file_names = zip_ref.namelist()
+ if in_place:
+ zip_dir = log_zip_file.parent
+ else:
+ zip_dir = log_zip_file.with_suffix('')
+ zip_ref.extractall(zip_dir)
+ unzipped_files = [
+ os.path.join(zip_dir, file_name) for file_name in file_names
+ ]
+ return unzipped_files
+
+ def unzip_modem_logs(self, log_zip_file):
+ log_files = self._unzip_log(log_zip_file, in_place=0)
+ sdm_files = []
+ for log_file in log_files:
+ if zipfile.is_zipfile(log_file):
+ sdm_files.append(self._unzip_log(log_file, in_place=1)[0])
+ os.remove(log_file)
+ elif Path(
+ log_file
+ ).suffix == '.sdm' and 'sbuff_power_on_log.sdm' not in log_file:
+ sdm_files.append(log_file)
+ return sorted(set(sdm_files))
+
+ def _export_single_log(self, file):
+ temp_file = str(Path(file).with_suffix('.csv'))
+ if self.filter_file:
+ export_cmd = [
+ self.dm_app, 'traceexport', '-c', '-csv', '-f',
+ self.filter_file, '-b', self.modem_bin, '-o', temp_file, file
+ ]
+ else:
+ export_cmd = [
+ self.dm_app, 'traceexport', '-c', '-csv', '-b', self.modem_bin,
+ '-o', temp_file, file
+ ]
+ logging.debug('Executing: {}'.format(export_cmd))
+ subprocess.call(export_cmd)
+ return temp_file
+
+ def _export_logs(self, log_files):
+ csv_files = []
+ for file in log_files:
+ csv_files.append(self._export_single_log(file))
+ return csv_files
+
+ def _filter_log(self, input_filename, output_filename, write_header):
+ """Export log messages from input file to output file."""
+ log_parser = LogParser()
+ with open(input_filename, 'r') as input_file:
+ with open(output_filename, 'a') as output_file:
+
+ header_line = input_file.readline()
+ log_parser.parse_header(header_line)
+ if log_parser.message_col == -1:
+ return
+
+ if write_header:
+ output_file.write(header_line)
+ # Write next line for time reference.
+ output_file.write(input_file.readline())
+
+ for line in input_file:
+ message = log_parser.get_message(line)
+ if message:
+ for filter_str in log_parser.PARSER_INFO:
+ if message.startswith(filter_str):
+ output_file.write(line)
+ break
+
+ def _export_filtered_logs(self, csv_files):
+ start_times = []
+ log_parser = LogParser()
+ reordered_csv_files = []
+ for file in csv_files:
+ start_time = log_parser.get_file_start_time(file)
+ if start_time:
+ start_times.append(start_time)
+ reordered_csv_files.append(file)
+ print(reordered_csv_files)
+ print(start_times)
+ file_order = numpy.argsort(start_times)
+ print(file_order)
+ reordered_csv_files = [reordered_csv_files[i] for i in file_order]
+ print(reordered_csv_files)
+ log_directory = Path(reordered_csv_files[0]).parent
+ exported_file = os.path.join(log_directory, 'modem_log.csv')
+ write_header = True
+ for file in reordered_csv_files:
+ self._filter_log(file, exported_file, write_header)
+ write_header = False
+ return exported_file
+
+ def _parse_log(self, log_file, gap_options=0):
+ """Extract required data from the exported CSV file."""
+ log_parser = LogParser()
+ log_data = log_parser.parse_log(log_file, gap_options=0)
+ return log_data
+
+ def process_log(self, log_zip_file):
+ sdm_log_files = self.unzip_modem_logs(log_zip_file)
+ csv_log_files = self._export_logs(sdm_log_files)
+ exported_log = self._export_filtered_logs(csv_log_files)
+ log_data = self._parse_log(exported_log, 0)
+ for file in itertools.chain(sdm_log_files, csv_log_files):
+ os.remove(file)
+ return log_data
diff --git a/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py b/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py
index 9fe9fa4..f6d962f 100644
--- a/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py
+++ b/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py
@@ -13,40 +13,39 @@
# 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.
+'''GNSS Base Class for Blanking and Hot Start Sensitivity Search'''
import os
-from glob import glob
+import re
from time import sleep
from collections import namedtuple
+from itertools import product
from numpy import arange
-from pandas import DataFrame
+from pandas import DataFrame, merge
from acts.signals import TestError
from acts.signals import TestFailure
from acts.logger import epoch_to_log_line_timestamp
from acts.context import get_current_context
from acts_contrib.test_utils.gnss import LabTtffTestBase as lttb
+from acts_contrib.test_utils.gnss.LabTtffTestBase import glob_re
from acts_contrib.test_utils.gnss.gnss_test_utils import launch_eecoexer
-from acts_contrib.test_utils.gnss.gnss_test_utils import excute_eecoexer_function
+from acts_contrib.test_utils.gnss.gnss_test_utils import execute_eecoexer_function
from acts_contrib.test_utils.gnss.gnss_test_utils import start_gnss_by_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import get_current_epoch_time
from acts_contrib.test_utils.gnss.gnss_test_utils import check_current_focus_app
from acts_contrib.test_utils.gnss.gnss_test_utils import process_ttff_by_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import check_ttff_data
from acts_contrib.test_utils.gnss.gnss_test_utils import process_gnss_by_gtw_gpstool
-from acts_contrib.test_utils.gnss.gnss_test_utils import start_pixel_logger
-from acts_contrib.test_utils.gnss.gnss_test_utils import stop_pixel_logger
-from acts_contrib.test_utils.gnss.dut_log_test_utils import start_diagmdlog_background
from acts_contrib.test_utils.gnss.dut_log_test_utils import get_gpstool_logs
-from acts_contrib.test_utils.gnss.dut_log_test_utils import stop_background_diagmdlog
-from acts_contrib.test_utils.gnss.dut_log_test_utils import get_pixellogger_bcm_log
from acts_contrib.test_utils.gnss.gnss_testlog_utils import parse_gpstool_ttfflog_to_df
-def range_wi_end(ad, start, stop, step):
+def range_wi_end(dut, start, stop, step):
"""
Generate a list of data from start to stop with the step. The list includes start and stop value
and also supports floating point.
Args:
+ dut: An AndroidDevice object.
start: start value.
Type, int or float.
stop: stop value.
@@ -57,7 +56,7 @@
range_ls: the list of data.
"""
if step == 0:
- ad.log.warn('Step is 0. Return empty list')
+ dut.log.warn('Step is 0. Return empty list')
range_ls = []
else:
if start == stop:
@@ -68,44 +67,50 @@
if (step < 0 and range_ls[-1] > stop) or (step > 0 and
range_ls[-1] < stop):
range_ls.append(stop)
+ dut.log.debug(f'The range list is: {range_ls}')
return range_ls
-def check_ttff_pe(ad, ttff_data, ttff_mode, pe_criteria):
+def check_ttff_pe(dut, ttff_data, ttff_mode, pe_criteria):
"""Verify all TTFF results from ttff_data.
Args:
- ad: An AndroidDevice object.
+ dut: An AndroidDevice object.
ttff_data: TTFF data of secs, position error and signal strength.
ttff_mode: TTFF Test mode for current test item.
pe_criteria: Criteria for current test item.
"""
ret = True
- ad.log.info("%d iterations of TTFF %s tests finished." %
- (len(ttff_data.keys()), ttff_mode))
- ad.log.info("%s PASS criteria is %f meters" % (ttff_mode, pe_criteria))
- ad.log.debug("%s TTFF data: %s" % (ttff_mode, ttff_data))
+ no_iteration = len(ttff_data.keys())
+ dut.log.info(
+ f'{no_iteration} iterations of TTFF {ttff_mode} tests finished.')
+ dut.log.info(f'{ttff_mode} PASS criteria is {pe_criteria} meters')
+ dut.log.debug(f'{ttff_mode} TTFF data: {ttff_data}')
if len(ttff_data.keys()) == 0:
- ad.log.error("GTW_GPSTool didn't process TTFF properly.")
+ dut.log.error("GTW_GPSTool didn't process TTFF properly.")
raise TestFailure("GTW_GPSTool didn't process TTFF properly.")
if any(
float(ttff_data[key].ttff_pe) >= pe_criteria
for key in ttff_data.keys()):
- ad.log.error("One or more TTFF %s are over test criteria %f meters" %
- (ttff_mode, pe_criteria))
+ dut.log.error(
+ f'One or more TTFF {ttff_mode} are over test criteria {pe_criteria} meters'
+ )
ret = False
else:
- ad.log.info("All TTFF %s are within test criteria %f meters." %
- (ttff_mode, pe_criteria))
+ dut.log.info(
+ f'All TTFF {ttff_mode} are within test criteria {pe_criteria} meters.'
+ )
ret = True
return ret
class GnssBlankingBase(lttb.LabTtffTestBase):
""" LAB GNSS Cellular Coex Tx Power Sweep TTFF/FFPE Tests"""
+ GNSS_PWR_SWEEP = 'gnss_pwr_sweep'
+ CELL_PWR_SWEEP = 'cell_pwr_sweep'
def __init__(self, controllers):
""" Initializes class attributes. """
@@ -118,22 +123,28 @@
self.gsm_sweep_params = None
self.lte_tdd_pc3_sweep_params = None
self.lte_tdd_pc2_sweep_params = None
- self.sa_sensitivity = -150
- self.gnss_pwr_lvl_offset = -5
- self.maskfile = None
+ self.coex_stop_cmd = None
+ self.scen_sweep = False
+ self.gnss_pwr_sweep_init_ls = []
+ self.gnss_pwr_sweep_fine_sweep_ls = []
def setup_class(self):
super().setup_class()
- req_params = ['sa_sensitivity', 'gnss_pwr_lvl_offset']
+
+ # Required parameters
+ req_params = [self.GNSS_PWR_SWEEP]
self.unpack_userparams(req_param_names=req_params)
- cell_sweep_params = self.user_params.get('cell_pwr_sweep', [])
- self.gsm_sweep_params = cell_sweep_params.get("GSM", [10, 33, 1])
- self.lte_tdd_pc3_sweep_params = cell_sweep_params.get(
- "LTE_TDD_PC3", [10, 24, 1])
- self.lte_tdd_pc2_sweep_params = cell_sweep_params.get(
- "LTE_TDD_PC2", [10, 26, 1])
- self.sa_sensitivity = self.user_params.get('sa_sensitivity', -150)
- self.gnss_pwr_lvl_offset = self.user_params.get('gnss_pwr_lvl_offset', -5)
+ self.unpack_gnss_pwr_sweep()
+
+ # Optional parameters
+ cell_sweep_params = self.user_params.get(self.CELL_PWR_SWEEP, [])
+
+ if cell_sweep_params:
+ self.gsm_sweep_params = cell_sweep_params.get("GSM", [10, 33, 1])
+ self.lte_tdd_pc3_sweep_params = cell_sweep_params.get(
+ "LTE_TDD_PC3", [10, 24, 1])
+ self.lte_tdd_pc2_sweep_params = cell_sweep_params.get(
+ "LTE_TDD_PC2", [10, 26, 1])
def setup_test(self):
super().setup_test()
@@ -148,11 +159,8 @@
self.gnss_log_path = os.path.join(self.log_path, cur_test_item_dir)
os.makedirs(self.gnss_log_path, exist_ok=True)
- # Start GNSS chip log
- if self.diag_option == "QCOM":
- start_diagmdlog_background(self.dut, maskfile=self.maskfile)
- else:
- start_pixel_logger(self.dut)
+ ## Start GNSS chip log
+ self.start_dut_gnss_log()
def teardown_test(self):
super().teardown_test()
@@ -161,35 +169,69 @@
self.diag_option)
os.makedirs(gnss_vendor_log_path, exist_ok=True)
- # Stop GNSS chip log and pull the logs to local file system.
- if self.diag_option == "QCOM":
- stop_background_diagmdlog(self.dut,
- gnss_vendor_log_path,
- keep_logs=False)
- else:
- stop_pixel_logger(self.dut)
- self.log.info('Getting Pixel BCM Log!')
- get_pixellogger_bcm_log(self.dut,
- gnss_vendor_log_path,
- keep_logs=False)
+ # Stop GNSS chip log and pull the logs to local file system
+ self.stop_and_pull_dut_gnss_log(gnss_vendor_log_path)
# Stop cellular Tx and close GPStool and EEcoexer APPs.
- self.stop_cell_tx()
+ self.stop_coex_tx()
self.log.debug('Close GPStool APP')
self.dut.force_stop_apk("com.android.gpstool")
self.log.debug('Close EEcoexer APP')
self.dut.force_stop_apk("com.google.eecoexer")
- def stop_cell_tx(self):
+ def derive_sweep_list(self, data):
+ """
+ Derive sweep list from config
+ Args:
+ data: GNSS simulator scenario power setting.
+ type, dictionary.
+ """
+ match_tag = r'(?P<sat>[a-z]+)_(?P<band>[a-z]+\d\S*)'
+ sweep_all_ls = []
+ set_all_ls = []
+ regex_match = re.compile(match_tag)
+ method = data.get('method')
+ for key, value in data.items():
+ result = regex_match.search(key)
+ if result:
+ set_all_ls.append(result.groupdict())
+ sweep_all_ls.append(
+ range_wi_end(self.dut, value[0], value[1], value[2]))
+ if method == 'product':
+ swp_result_ls = list(product(*sweep_all_ls))
+ else:
+ swp_result_ls = list(zip(*sweep_all_ls))
+
+ self.log.debug(f'set_all_ls: {set_all_ls}')
+ self.log.debug(f'swp_result_ls: {swp_result_ls}')
+ return set_all_ls, swp_result_ls
+
+ def unpack_gnss_pwr_sweep(self):
+ """ Unpack gnss_pwr_sweep and construct sweep parameters
+ """
+
+ for key, value in self.gnss_pwr_sweep.items():
+ if key == 'init':
+ self.gnss_pwr_sweep_init_ls = []
+ self.log.info(f'Sweep: {value}')
+ result = self.derive_sweep_list(value)
+ self.gnss_pwr_sweep_init_ls.append(result)
+ elif key == 'fine_sweep':
+ self.gnss_pwr_sweep_fine_sweep_ls = []
+ self.log.info(f'Sweep: {value}')
+ result = self.derive_sweep_list(value)
+ self.gnss_pwr_sweep_fine_sweep_ls.append(result)
+ else:
+ self.log.error(f'{key} is a unsupported key in gnss_pwr_sweep.')
+
+ def stop_coex_tx(self):
"""
Stop EEcoexer Tx power.
"""
- # EEcoexer cellular stop Tx command.
- stop_cell_tx_cmd = 'CELLR,19'
-
# Stop cellular Tx by EEcoexer.
- self.log.info('Stop EEcoexer Test Command: {}'.format(stop_cell_tx_cmd))
- excute_eecoexer_function(self.dut, stop_cell_tx_cmd)
+ if self.coex_stop_cmd:
+ self.log.info(f'Stop EEcoexer Test Command: {self.coex_stop_cmd}')
+ execute_eecoexer_function(self.dut, self.coex_stop_cmd)
def analysis_ttff_ffpe(self, ttff_data, json_tag=''):
"""
@@ -208,45 +250,81 @@
get_gpstool_logs(self.dut, gps_log_path, False)
# Parsing the log of GTW GPStool into pandas dataframe.
- target_log_name_regx = os.path.join(gps_log_path, 'GPSLogs', 'files',
- 'GNSS_*')
- self.log.info('Get GPStool logs from: {}'.format(target_log_name_regx))
- gps_api_log_ls = glob(target_log_name_regx)
+ target_dir = os.path.join(gps_log_path, 'GPSLogs', 'files')
+ gps_api_log_ls = glob_re(self.dut, target_dir, r'GNSS_\d+')
latest_gps_api_log = max(gps_api_log_ls, key=os.path.getctime)
- self.log.info(
- 'Get latest GPStool log is: {}'.format(latest_gps_api_log))
+ self.log.info(f'Get latest GPStool log is: {latest_gps_api_log}')
+ df_ttff_ffpe = DataFrame(
+ parse_gpstool_ttfflog_to_df(latest_gps_api_log))
+ # Add test case, TTFF and FFPE data into the dataframe.
+ ttff_dict = {}
+ for i in ttff_data:
+ data = ttff_data[i]._asdict()
+ ttff_dict[i] = dict(data)
+
+ ttff_data_df = DataFrame(ttff_dict).transpose()
+ ttff_data_df = ttff_data_df[[
+ 'ttff_loop', 'ttff_sec', 'ttff_pe', 'ttff_haccu'
+ ]]
try:
- df_ttff_ffpe = DataFrame(
- parse_gpstool_ttfflog_to_df(latest_gps_api_log))
+ df_ttff_ffpe = merge(df_ttff_ffpe,
+ ttff_data_df,
+ left_on='loop',
+ right_on='ttff_loop')
+ except: # pylint: disable=bare-except
+ self.log.warning("Can't merge ttff_data and df.")
+ df_ttff_ffpe['test_case'] = json_tag
- # Add test case, TTFF and FFPE data into the dataframe.
- ttff_dict = {}
- for i in ttff_data:
- data = ttff_data[i]._asdict()
- ttff_dict[i] = dict(data)
- ttff_time = []
- ttff_pe = []
- test_case = []
- for value in ttff_dict.values():
- ttff_time.append(value['ttff_sec'])
- ttff_pe.append(value['ttff_pe'])
- test_case.append(json_tag)
- self.log.info('test_case length {}'.format(str(len(test_case))))
+ json_file = f'gps_log_{json_tag}.json'
+ ttff_data_json_file = f'gps_log_{json_tag}_ttff_data.json'
+ json_path = os.path.join(gps_log_path, json_file)
+ ttff_data_json_path = os.path.join(gps_log_path, ttff_data_json_file)
+ # Save dataframe into json file.
+ df_ttff_ffpe.to_json(json_path, orient='table', index=False)
+ ttff_data_df.to_json(ttff_data_json_path, orient='table', index=False)
- df_ttff_ffpe['test_case'] = test_case
- df_ttff_ffpe['ttff_sec'] = ttff_time
- df_ttff_ffpe['ttff_pe'] = ttff_pe
- json_file = 'gps_log_{}.json'.format(json_tag)
- json_path = os.path.join(gps_log_path, json_file)
- # Save dataframe into json file.
- df_ttff_ffpe.to_json(json_path, orient='table', index=False)
- except ValueError:
- self.log.warning('Can\'t create the parsed the log data in file.')
+ def hot_start_ttff_ffpe_process(self, iteration, wait):
+ """
+ Function to run hot start TTFF/FFPE by GTW GPSTool
+ Args:
+ iteration: TTFF/FFPE test iteration.
+ type, integer.
+ wait: wait time before the hot start TTFF/FFPE test.
+ type, integer.
+ """
+ # Start GTW GPStool.
+ self.dut.log.info("Restart GTW GPSTool")
+ start_gnss_by_gtw_gpstool(self.dut, state=True)
+ if wait > 0:
+ self.log.info(
+ f'Wait for {wait} seconds before TTFF to acquire data.')
+ sleep(wait)
+ # Get current time and convert to human readable format
+ begin_time = get_current_epoch_time()
+ log_begin_time = epoch_to_log_line_timestamp(begin_time)
+ self.dut.log.debug(f'Start time is {log_begin_time}')
+
+ # Run hot start TTFF
+ for i in range(3):
+ self.log.info(f'Start hot start attempt {i + 1}')
+ self.dut.adb.shell(
+ f'am broadcast -a com.android.gpstool.ttff_action '
+ f'--es ttff hs --es cycle {iteration} --ez raninterval False')
+ sleep(1)
+ if self.dut.search_logcat(
+ "act=com.android.gpstool.start_test_action", begin_time):
+ self.dut.log.info("Send TTFF start_test_action successfully.")
+ break
+ else:
+ check_current_focus_app(self.dut)
+ raise TestError("Fail to send TTFF start_test_action.")
+ return begin_time
def gnss_hot_start_ttff_ffpe_test(self,
iteration,
sweep_enable=False,
- json_tag=''):
+ json_tag='',
+ wait=0):
"""
GNSS hot start ttff ffpe tset
@@ -261,40 +339,26 @@
this as a part of file name to save TTFF and FFPE results into json file.
Type, str.
Default, ''.
+ wait: wait time before ttff test.
+ Type, int.
+ Default, 0.
Raise:
TestError: fail to send TTFF start_test_action.
"""
- # Start GTW GPStool.
test_type = namedtuple('Type', ['command', 'criteria'])
- test_type_ttff = test_type('Hot Start', self.hs_ttff_criteria)
+ test_type_ttff = test_type('Hot Start', self.hs_criteria)
test_type_pe = test_type('Hot Start', self.hs_ttff_pecriteria)
- self.dut.log.info("Restart GTW GPSTool")
- start_gnss_by_gtw_gpstool(self.dut, state=True)
-
- # Get current time and convert to human readable format
- begin_time = get_current_epoch_time()
- log_begin_time = epoch_to_log_line_timestamp(begin_time)
- self.dut.log.debug('Start time is {}'.format(log_begin_time))
-
- # Run hot start TTFF
- for i in range(3):
- self.log.info('Start hot start attempt %d' % (i + 1))
- self.dut.adb.shell(
- "am broadcast -a com.android.gpstool.ttff_action "
- "--es ttff hs --es cycle {} --ez raninterval False".format(
- iteration))
- sleep(1)
- if self.dut.search_logcat(
- "act=com.android.gpstool.start_test_action", begin_time):
- self.dut.log.info("Send TTFF start_test_action successfully.")
- break
- else:
- check_current_focus_app(self.dut)
- raise TestError("Fail to send TTFF start_test_action.")
# Verify hot start TTFF results
- ttff_data = process_ttff_by_gtw_gpstool(self.dut, begin_time,
- self.simulator_location)
+ begin_time = self.hot_start_ttff_ffpe_process(iteration, wait)
+ try:
+ ttff_data = process_ttff_by_gtw_gpstool(self.dut, begin_time,
+ self.simulator_location)
+ except: # pylint: disable=bare-except
+ self.log.warning('Fail to acquire TTFF data. Retry again.')
+ begin_time = self.hot_start_ttff_ffpe_process(iteration, wait)
+ ttff_data = process_ttff_by_gtw_gpstool(self.dut, begin_time,
+ self.simulator_location)
# Stop GTW GPSTool
self.dut.log.info("Stop GTW GPSTool")
@@ -320,10 +384,8 @@
return True
def hot_start_gnss_power_sweep(self,
- start_pwr,
- stop_pwr,
- offset,
- wait,
+ sweep_ls,
+ wait=0,
iteration=1,
sweep_enable=False,
title=''):
@@ -331,14 +393,11 @@
GNSS simulator power sweep of hot start test.
Args:
- start_pwr: GNSS simulator power sweep start power level.
- Type, int.
- stop_pwr: GNSS simulator power sweep stop power level.
- Type, int.
- offset: GNSS simulator power sweep offset
- Type, int.
+ sweep_ls: list of sweep parameters.
+ Type, tuple.
wait: Wait time before the power sweep.
Type, int.
+ Default, 0.
iteration: The iteration times of hot start test.
Type, int.
Default, 1.
@@ -349,15 +408,15 @@
title: the target log folder title for GNSS sensitivity search test items.
Type, str.
Default, ''.
+ Return:
+ Bool, gnss_pwr_params.
"""
# Calculate loop range list from gnss_simulator_power_level and sa_sensitivity
- range_ls = range_wi_end(self.dut, start_pwr, stop_pwr, offset)
- sweep_range = ','.join([str(x) for x in range_ls])
self.log.debug(
- 'Start the GNSS simulator power sweep. The sweep range is [{}]'.
- format(sweep_range))
+ f'Start the GNSS simulator power sweep. The sweep tuple is [{sweep_ls}]'
+ )
if sweep_enable:
self.start_gnss_and_wait(wait)
@@ -368,21 +427,41 @@
# Sweep GNSS simulator power level in range_ls.
# Do hot start for every power level.
# Check the TTFF result if it can pass the criteria.
- gnss_pwr_lvl = -130
- for gnss_pwr_lvl in range_ls:
-
- # Set GNSS Simulator power level
- self.log.info('Set GNSS simulator power level to %.1f' %
- gnss_pwr_lvl)
- self.gnss_simulator.set_power(gnss_pwr_lvl)
- json_tag = title + '_gnss_pwr_' + str(gnss_pwr_lvl)
-
+ gnss_pwr_params = None
+ previous_pwr_lvl = None
+ current_pwr_lvl = None
+ return_pwr_lvl = {}
+ for j, gnss_pwr_params in enumerate(sweep_ls[1]):
+ json_tag = f'{title}_'
+ current_pwr_lvl = gnss_pwr_params
+ if j == 0:
+ previous_pwr_lvl = current_pwr_lvl
+ for i, pwr in enumerate(gnss_pwr_params):
+ sat_sys = sweep_ls[0][i].get('sat').upper()
+ band = sweep_ls[0][i].get('band').upper()
+ # Set GNSS Simulator power level
+ self.gnss_simulator.ping_inst()
+ self.gnss_simulator.set_scenario_power(power_level=pwr,
+ sat_system=sat_sys,
+ freq_band=band)
+ self.log.info(f'Set {sat_sys} {band} with power {pwr}')
+ json_tag = json_tag + f'{sat_sys}_{band}_{pwr}'
+ # Wait 30 seconds if major power sweep level is changed.
+ wait = 0
+ if j > 0:
+ if current_pwr_lvl[0] != previous_pwr_lvl[0]:
+ wait = 30
# GNSS hot start test
if not self.gnss_hot_start_ttff_ffpe_test(iteration, sweep_enable,
- json_tag):
- sensitivity = gnss_pwr_lvl - offset
- return False, sensitivity
- return True, gnss_pwr_lvl
+ json_tag, wait):
+ result = False
+ break
+ previous_pwr_lvl = current_pwr_lvl
+ result = True
+ for i, pwr in enumerate(previous_pwr_lvl):
+ key = f'{sweep_ls[0][i].get("sat").upper()}_{sweep_ls[0][i].get("band").upper()}'
+ return_pwr_lvl.setdefault(key, pwr)
+ return result, return_pwr_lvl
def gnss_init_power_setting(self, first_wait=180):
"""
@@ -398,39 +477,22 @@
"""
# Start and set GNSS simulator
- self.start_and_set_gnss_simulator_power()
+ self.start_set_gnss_power()
# Start 1st time cold start to obtain ephemeris
process_gnss_by_gtw_gpstool(self.dut, self.test_types['cs'].criteria)
- self.hot_start_gnss_power_sweep(self.gnss_simulator_power_level,
- self.sa_sensitivity,
- self.gnss_pwr_lvl_offset, first_wait)
+ # Read initial power sweep settings
+ if self.gnss_pwr_sweep_init_ls:
+ for sweep_ls in self.gnss_pwr_sweep_init_ls:
+ ret, gnss_pwr_lvl = self.hot_start_gnss_power_sweep(
+ sweep_ls, first_wait)
+ else:
+ self.log.warning('Skip initial power sweep.')
+ ret = False
+ gnss_pwr_lvl = None
- return True
-
- def start_gnss_and_wait(self, wait=60):
- """
- The process of enable gnss and spend the wait time for GNSS to
- gather enoung information that make sure the stability of testing.
-
- Args:
- wait: wait time between power sweep.
- Type, int.
- Default, 60.
- """
- # Create log path for waiting section logs of GPStool.
- gnss_wait_log_dir = os.path.join(self.gnss_log_path, 'GNSS_wait')
-
- # Enable GNSS to receive satellites' signals for "wait_between_pwr" seconds.
- self.log.info('Enable GNSS for searching satellites')
- start_gnss_by_gtw_gpstool(self.dut, state=True)
- self.log.info('Wait for {} seconds'.format(str(wait)))
- sleep(wait)
-
- # Stop GNSS and pull the logs.
- start_gnss_by_gtw_gpstool(self.dut, state=False)
- get_gpstool_logs(self.dut, gnss_wait_log_dir, False)
+ return ret, gnss_pwr_lvl
def cell_power_sweep(self):
"""
@@ -449,9 +511,6 @@
power_search_ls = range_wi_end(self.dut, self.start_pwr, self.stop_pwr,
self.offset)
- # Set GNSS simulator power level.
- self.gnss_simulator.set_power(self.sa_sensitivity)
-
# Create gnss log folders for init and cellular sweep
gnss_init_log_dir = os.path.join(self.gnss_log_path, 'GNSS_init')
@@ -461,8 +520,8 @@
if power_search_ls:
# Run the cellular and GNSS coexistence test item.
for i, pwr_lvl in enumerate(power_search_ls):
- self.log.info('Cellular power sweep loop: {}'.format(int(i)))
- self.log.info('Cellular target power: {}'.format(int(pwr_lvl)))
+ self.log.info(f'Cellular power sweep loop: {i}')
+ self.log.info(f'Cellular target power: {pwr_lvl}')
# Enable GNSS to receive satellites' signals for "wait_between_pwr" seconds.
# Wait more time before 1st power level
@@ -473,9 +532,9 @@
self.start_gnss_and_wait(wait)
# Set cellular Tx power level.
- eecoex_cmd = self.eecoex_func.format(str(pwr_lvl))
+ eecoex_cmd = self.eecoex_func.format(pwr_lvl)
eecoex_cmd_file_str = eecoex_cmd.replace(',', '_')
- excute_eecoexer_function(self.dut, eecoex_cmd)
+ execute_eecoexer_function(self.dut, eecoex_cmd)
# Get the last power level that can pass hots start ttff/ffpe spec.
if self.gnss_hot_start_ttff_ffpe_test(ttft_iteration, True,
@@ -489,7 +548,7 @@
power_th = power_search_ls[i - 1]
# Stop cellular Tx after a test cycle.
- self.stop_cell_tx()
+ self.stop_coex_tx()
else:
# Run the stand alone test item.
@@ -499,7 +558,6 @@
self.gnss_hot_start_ttff_ffpe_test(ttft_iteration, True,
eecoex_cmd_file_str)
- self.log.info('The GNSS WWAN coex celluar Tx power is {}'.format(
- str(power_th)))
+ self.log.info(f'The GNSS WWAN coex celluar Tx power is {power_th}')
return power_th
diff --git a/acts_tests/acts_contrib/test_utils/gnss/LabTtffTestBase.py b/acts_tests/acts_contrib/test_utils/gnss/LabTtffTestBase.py
index 6a6bd5d..77ebcf6 100644
--- a/acts_tests/acts_contrib/test_utils/gnss/LabTtffTestBase.py
+++ b/acts_tests/acts_contrib/test_utils/gnss/LabTtffTestBase.py
@@ -13,35 +13,51 @@
# 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.
+'''GNSS Base Class for Lab TTFF/FFPE'''
import os
import time
-import glob
import errno
+import re
from collections import namedtuple
-from pandas import DataFrame
-from acts import utils
-from acts import signals
-from acts.base_test import BaseTestClass
-from acts.controllers.gnss_lib import GnssSimulator
-from acts.context import get_current_context
-from acts_contrib.test_utils.gnss import dut_log_test_utils as diaglog
-from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
-from acts_contrib.test_utils.gnss import gnss_testlog_utils as glogutils
+from pandas import DataFrame, merge
from acts_contrib.test_utils.gnss.gnss_defines import DEVICE_GPSLOG_FOLDER
from acts_contrib.test_utils.gnss.gnss_defines import GPS_PKG_NAME
from acts_contrib.test_utils.gnss.gnss_defines import BCM_GPS_XML_PATH
+from acts_contrib.test_utils.gnss import dut_log_test_utils as diaglog
+from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
+from acts_contrib.test_utils.gnss import gnss_testlog_utils as glogutils
+from acts import utils
+from acts import signals
+from acts.controllers.gnss_lib import GnssSimulator
+from acts.context import get_current_context
+from acts.base_test import BaseTestClass
+
+
+def glob_re(dut, directory, regex_tag):
+ """glob with regular expression method.
+ Args:
+ dut: An AndroidDevice object.
+ directory: Target directory path.
+ Type, str
+ regex_tag: regular expression format string.
+ Type, str
+ Return:
+ result_ls: list of glob result
+ """
+ all_files_in_dir = os.listdir(directory)
+ dut.log.debug(f'glob_re dir: {all_files_in_dir}')
+ target_log_name_regx = re.compile(regex_tag)
+ tmp_ls = list(filter(target_log_name_regx.match, all_files_in_dir))
+ result_ls = [os.path.join(directory, file) for file in tmp_ls]
+ dut.log.debug(f'glob_re list: {result_ls}')
+ return result_ls
class LabTtffTestBase(BaseTestClass):
""" LAB TTFF Tests Base Class"""
GTW_GPSTOOL_APP = 'gtw_gpstool_apk'
- GNSS_SIMULATOR_KEY = 'gnss_simulator'
- GNSS_SIMULATOR_IP_KEY = 'gnss_simulator_ip'
- GNSS_SIMULATOR_PORT_KEY = 'gnss_simulator_port'
- GNSS_SIMULATOR_PORT_CTRL_KEY = 'gnss_simulator_port_ctrl'
- GNSS_SIMULATOR_SCENARIO_KEY = 'gnss_simulator_scenario'
- GNSS_SIMULATOR_POWER_LEVEL_KEY = 'gnss_simulator_power_level'
+ GNSS_SIMULATOR_KEY = 'gnss_sim_params'
CUSTOM_FILES_KEY = 'custom_files'
CSTTFF_CRITERIA = 'cs_criteria'
HSTTFF_CRITERIA = 'hs_criteria'
@@ -52,76 +68,106 @@
TTFF_ITERATION = 'ttff_iteration'
SIMULATOR_LOCATION = 'simulator_location'
DIAG_OPTION = 'diag_option'
+ SCENARIO_POWER = 'scenario_power'
+ MDSAPP = 'mdsapp'
+ MASKFILE = 'maskfile'
+ MODEMPARFILE = 'modemparfile'
+ NV_DICT = 'nv_dict'
+ TTFF_TIMEOUT = 'ttff_timeout'
def __init__(self, controllers):
""" Initializes class attributes. """
super().__init__(controllers)
-
self.dut = None
self.gnss_simulator = None
self.rockbottom_script = None
self.gnss_log_path = self.log_path
self.gps_xml_bk_path = BCM_GPS_XML_PATH + '.bk'
+ self.gpstool_ver = ''
+ self.test_params = None
+ self.custom_files = None
+ self.maskfile = None
+ self.mdsapp = None
+ self.modemparfile = None
+ self.nv_dict = None
+ self.scenario_power = None
+ self.ttff_timeout = None
+ self.test_types = None
+ self.simulator_location = None
+ self.gnss_simulator_scenario = None
+ self.gnss_simulator_power_level = None
def setup_class(self):
super().setup_class()
- req_params = [
- self.GNSS_SIMULATOR_KEY, self.GNSS_SIMULATOR_IP_KEY,
- self.GNSS_SIMULATOR_PORT_KEY, self.GNSS_SIMULATOR_SCENARIO_KEY,
- self.GNSS_SIMULATOR_POWER_LEVEL_KEY, self.CSTTFF_CRITERIA,
- self.HSTTFF_CRITERIA, self.WSTTFF_CRITERIA, self.TTFF_ITERATION,
- self.SIMULATOR_LOCATION, self.DIAG_OPTION
- ]
+ # Update parameters by test case configurations.
+ test_param = self.TAG + '_params'
+ self.test_params = self.user_params.get(test_param, {})
+ if not self.test_params:
+ self.log.warning(test_param + ' was not found in the user '
+ 'parameters defined in the config file.')
+ # Override user_param values with test parameters
+ self.user_params.update(self.test_params)
+
+ # Unpack user_params with default values. All the usages of user_params
+ # as self attributes need to be included either as a required parameter
+ # or as a parameter with a default value.
+
+ # Required parameters
+ req_params = [
+ self.CSTTFF_PECRITERIA, self.WSTTFF_PECRITERIA, self.HSTTFF_PECRITERIA,
+ self.CSTTFF_CRITERIA, self.HSTTFF_CRITERIA, self.WSTTFF_CRITERIA,
+ self.TTFF_ITERATION, self.GNSS_SIMULATOR_KEY, self.DIAG_OPTION,
+ self.GTW_GPSTOOL_APP
+ ]
self.unpack_userparams(req_param_names=req_params)
+
+ # Optional parameters
+ self.custom_files = self.user_params.get(self.CUSTOM_FILES_KEY,[])
+ self.maskfile = self.user_params.get(self.MASKFILE,'')
+ self.mdsapp = self.user_params.get(self.MDSAPP,'')
+ self.modemparfile = self.user_params.get(self.MODEMPARFILE,'')
+ self.nv_dict = self.user_params.get(self.NV_DICT,{})
+ self.scenario_power = self.user_params.get(self.SCENARIO_POWER, [])
+ self.ttff_timeout = self.user_params.get(self.TTFF_TIMEOUT, 60)
+
+ # Set TTFF Spec.
+ test_type = namedtuple('Type', ['command', 'criteria'])
+ self.test_types = {
+ 'cs': test_type('Cold Start', self.cs_criteria),
+ 'ws': test_type('Warm Start', self.ws_criteria),
+ 'hs': test_type('Hot Start', self.hs_criteria)
+ }
+
self.dut = self.android_devices[0]
- self.gnss_simulator_scenario = self.user_params[
- self.GNSS_SIMULATOR_SCENARIO_KEY]
- self.gnss_simulator_power_level = self.user_params[
- self.GNSS_SIMULATOR_POWER_LEVEL_KEY]
- self.gtw_gpstool_app = self.user_params[self.GTW_GPSTOOL_APP]
- custom_files = self.user_params.get(self.CUSTOM_FILES_KEY, [])
- self.cs_ttff_criteria = self.user_params.get(self.CSTTFF_CRITERIA, [])
- self.hs_ttff_criteria = self.user_params.get(self.HSTTFF_CRITERIA, [])
- self.ws_ttff_criteria = self.user_params.get(self.WSTTFF_CRITERIA, [])
- self.cs_ttff_pecriteria = self.user_params.get(self.CSTTFF_PECRITERIA,
- [])
- self.hs_ttff_pecriteria = self.user_params.get(self.HSTTFF_PECRITERIA,
- [])
- self.ws_ttff_pecriteria = self.user_params.get(self.WSTTFF_PECRITERIA,
- [])
- self.ttff_iteration = self.user_params.get(self.TTFF_ITERATION, [])
- self.simulator_location = self.user_params.get(self.SIMULATOR_LOCATION,
- [])
- self.diag_option = self.user_params.get(self.DIAG_OPTION, [])
+
+ # GNSS Simulator Setup
+ self.simulator_location = self.gnss_sim_params.get(
+ self.SIMULATOR_LOCATION, [])
+ self.gnss_simulator_scenario = self.gnss_sim_params.get('scenario')
+ self.gnss_simulator_power_level = self.gnss_sim_params.get(
+ 'power_level')
# Create gnss_simulator instance
- gnss_simulator_key = self.user_params[self.GNSS_SIMULATOR_KEY]
- gnss_simulator_ip = self.user_params[self.GNSS_SIMULATOR_IP_KEY]
- gnss_simulator_port = self.user_params[self.GNSS_SIMULATOR_PORT_KEY]
+ gnss_simulator_key = self.gnss_sim_params.get('type')
+ gnss_simulator_ip = self.gnss_sim_params.get('ip')
+ gnss_simulator_port = self.gnss_sim_params.get('port')
if gnss_simulator_key == 'gss7000':
- gnss_simulator_port_ctrl = self.user_params[
- self.GNSS_SIMULATOR_PORT_CTRL_KEY]
+ gnss_simulator_port_ctrl = self.gnss_sim_params.get('port_ctrl')
else:
gnss_simulator_port_ctrl = None
self.gnss_simulator = GnssSimulator.AbstractGnssSimulator(
gnss_simulator_key, gnss_simulator_ip, gnss_simulator_port,
gnss_simulator_port_ctrl)
- test_type = namedtuple('Type', ['command', 'criteria'])
- self.test_types = {
- 'cs': test_type('Cold Start', self.cs_ttff_criteria),
- 'ws': test_type('Warm Start', self.ws_ttff_criteria),
- 'hs': test_type('Hot Start', self.hs_ttff_criteria)
- }
-
# Unpack the rockbottom script file if its available.
- for file in custom_files:
- if 'rockbottom_' + self.dut.model in file:
- self.rockbottom_script = file
- break
+ if self.custom_files:
+ for file in self.custom_files:
+ if 'rockbottom_' + self.dut.model in file:
+ self.rockbottom_script = file
+ break
def setup_test(self):
@@ -129,25 +175,43 @@
self.gnss_simulator.stop_scenario()
self.gnss_simulator.close()
if self.rockbottom_script:
- self.log.info('Running rockbottom script for this device ' +
- self.dut.model)
+ self.log.info(
+ f'Running rockbottom script for this device {self.dut.model}')
self.dut_rockbottom()
else:
- self.log.info('Not running rockbottom for this device ' +
- self.dut.model)
+ self.log.info(
+ f'Not running rockbottom for this device {self.dut.model}')
utils.set_location_service(self.dut, True)
gutils.reinstall_package_apk(self.dut, GPS_PKG_NAME,
- self.gtw_gpstool_app)
+ self.gtw_gpstool_apk)
+ gpstool_ver_cmd = f'dumpsys package {GPS_PKG_NAME} | grep versionName'
+ self.gpstool_ver = self.dut.adb.shell(gpstool_ver_cmd).split('=')[1]
+ self.log.info(f'GTW GPSTool version: {self.gpstool_ver}')
# For BCM DUTs, delete gldata.sto and set IgnoreRomAlm="true" based on b/196936791#comment20
if self.diag_option == "BCM":
gutils.remount_device(self.dut)
# Backup gps.xml
- copy_cmd = "cp {} {}".format(BCM_GPS_XML_PATH, self.gps_xml_bk_path)
+ if self.dut.file_exists(BCM_GPS_XML_PATH):
+ copy_cmd = f'cp {BCM_GPS_XML_PATH} {self.gps_xml_bk_path}'
+ elif self.dut.file_exists(self.gps_xml_bk_path):
+ self.log.debug(f'{BCM_GPS_XML_PATH} is missing')
+ self.log.debug(
+ f'Copy {self.gps_xml_bk_path} and rename to {BCM_GPS_XML_PATH}'
+ )
+ copy_cmd = f'cp {self.gps_xml_bk_path} {BCM_GPS_XML_PATH}'
+ else:
+ self.log.error(
+ f'Missing both {BCM_GPS_XML_PATH} and {self.gps_xml_bk_path} in DUT'
+ )
+ raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
+ self.gps_xml_bk_path)
self.dut.adb.shell(copy_cmd)
gutils.delete_bcm_nvmem_sto_file(self.dut)
gutils.bcm_gps_ignore_rom_alm(self.dut)
+ if self.current_test_name == "test_tracking_power_sweep":
+ gutils.bcm_gps_ignore_warmstandby(self.dut)
# Reboot DUT to apply the setting
gutils.reboot(self.dut)
self.gnss_simulator.connect()
@@ -160,9 +224,9 @@
# The rockbottom script might include a device reboot, so it is
# necessary to stop SL4A during its execution.
self.dut.stop_services()
- self.log.info('Executing rockbottom script for ' + self.dut.model)
+ self.log.info(f'Executing rockbottom script for {self.dut.model}')
os.chmod(self.rockbottom_script, 0o777)
- os.system('{} {}'.format(self.rockbottom_script, self.dut.serial))
+ os.system(f'{self.rockbottom_script} {self.dut.serial}')
# Make sure the DUT is in root mode after coming back
self.dut.root_adb()
# Restart SL4A
@@ -174,9 +238,9 @@
# Restore the gps.xml everytime after the test.
if self.diag_option == "BCM":
# Restore gps.xml
- rm_cmd = "rm -rf {}".format(BCM_GPS_XML_PATH)
- restore_cmd = "mv {} {}".format(self.gps_xml_bk_path,
- BCM_GPS_XML_PATH)
+ gutils.remount_device(self.dut)
+ rm_cmd = f'rm -rf {BCM_GPS_XML_PATH}'
+ restore_cmd = f'cp {self.gps_xml_bk_path} {BCM_GPS_XML_PATH}'
self.dut.adb.shell(rm_cmd)
self.dut.adb.shell(restore_cmd)
@@ -187,7 +251,7 @@
self.gnss_simulator.stop_scenario()
self.gnss_simulator.close()
- def start_and_set_gnss_simulator_power(self):
+ def start_set_gnss_power(self):
"""
Start GNSS simulator secnario and set power level.
@@ -195,7 +259,24 @@
self.gnss_simulator.start_scenario(self.gnss_simulator_scenario)
time.sleep(25)
- self.gnss_simulator.set_power(self.gnss_simulator_power_level)
+ if self.scenario_power:
+ self.log.info(
+ 'Set GNSS simulator power with power_level by scenario_power')
+ for setting in self.scenario_power:
+ power_level = setting.get('power_level', -130)
+ sat_system = setting.get('sat_system', '')
+ freq_band = setting.get('freq_band', 'ALL')
+ sat_id = setting.get('sat_id', '')
+ self.log.debug(f'sat: {sat_system}; freq_band: {freq_band}, '
+ f'power_level: {power_level}, sat_id: {sat_id}')
+ self.gnss_simulator.set_scenario_power(power_level,
+ sat_id,
+ sat_system,
+ freq_band)
+ else:
+ self.log.debug('Set GNSS simulator power '
+ f'with power_level: {self.gnss_simulator_power_level}')
+ self.gnss_simulator.set_power(self.gnss_simulator_power_level)
def get_and_verify_ttff(self, mode):
"""Retrieve ttff with designate mode.
@@ -204,14 +285,9 @@
mode: A string for identify gnss test mode.
"""
if mode not in self.test_types:
- raise signals.TestError('Unrecognized mode %s' % mode)
+ raise signals.TestError(f'Unrecognized mode {mode}')
test_type = self.test_types.get(mode)
- if mode != 'cs':
- wait_time = 900
- else:
- wait_time = 300
-
gutils.process_gnss_by_gtw_gpstool(self.dut,
self.test_types['cs'].criteria)
begin_time = gutils.get_current_epoch_time()
@@ -219,12 +295,12 @@
ttff_mode=mode,
iteration=self.ttff_iteration,
raninterval=True,
- hot_warm_sleep=wait_time)
+ hot_warm_sleep=3,
+ timeout=self.ttff_timeout)
# Since Wear takes little longer to update the TTFF info.
# Workround to solve the wearable timing issue
if gutils.is_device_wearable(self.dut):
time.sleep(20)
-
ttff_data = gutils.process_ttff_by_gtw_gpstool(self.dut, begin_time,
self.simulator_location)
@@ -232,41 +308,43 @@
gps_log_path = os.path.join(self.gnss_log_path, 'GPSLogs')
os.makedirs(gps_log_path, exist_ok=True)
- self.dut.adb.pull("{} {}".format(DEVICE_GPSLOG_FOLDER, gps_log_path))
-
- gps_api_log = glob.glob(gps_log_path + '/*/GNSS_*.txt')
- ttff_loop_log = glob.glob(gps_log_path +
- '/*/GPS_{}_*.txt'.format(mode.upper()))
+ self.dut.adb.pull(f'{DEVICE_GPSLOG_FOLDER} {gps_log_path}')
+ local_log_dir = os.path.join(gps_log_path, 'files')
+ gps_api_log = glob_re(self.dut, local_log_dir, r'GNSS_\d+')
+ ttff_loop_log = glob_re(self.dut, local_log_dir,
+ fr'\w+_{mode.upper()}_\d+')
if not gps_api_log and ttff_loop_log:
raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
gps_log_path)
- df = DataFrame(glogutils.parse_gpstool_ttfflog_to_df(gps_api_log[0]))
+ df_ttff_ffpe = DataFrame(glogutils.parse_gpstool_ttfflog_to_df(gps_api_log[0]))
ttff_dict = {}
for i in ttff_data:
- d = ttff_data[i]._asdict()
- ttff_dict[i] = dict(d)
+ data = ttff_data[i]._asdict()
+ ttff_dict[i] = dict(data)
- ttff_time = []
- ttff_pe = []
- ttff_haccu = []
- for i in ttff_dict.keys():
- ttff_time.append(ttff_dict[i]['ttff_sec'])
- ttff_pe.append(ttff_dict[i]['ttff_pe'])
- ttff_haccu.append(ttff_dict[i]['ttff_haccu'])
- df['ttff_sec'] = ttff_time
- df['ttff_pe'] = ttff_pe
- df['ttff_haccu'] = ttff_haccu
- df.to_json(gps_log_path + '/gps_log.json', orient='table')
+ ttff_data_df = DataFrame(ttff_dict).transpose()
+ ttff_data_df = ttff_data_df[[
+ 'ttff_loop', 'ttff_sec', 'ttff_pe', 'ttff_haccu'
+ ]]
+ try:
+ df_ttff_ffpe = merge(df_ttff_ffpe, ttff_data_df, left_on='loop', right_on='ttff_loop')
+ except: # pylint: disable=bare-except
+ self.log.warning("Can't merge ttff_data and df.")
+ ttff_data_df.to_json(gps_log_path + '/gps_log_ttff_data.json',
+ orient='table',
+ index=False)
+ df_ttff_ffpe.to_json(gps_log_path + '/gps_log.json', orient='table', index=False)
result = gutils.check_ttff_data(self.dut,
ttff_data,
ttff_mode=test_type.command,
criteria=test_type.criteria)
if not result:
- raise signals.TestFailure('%s TTFF fails to reach '
- 'designated criteria' % test_type.command)
+ raise signals.TestFailure(
+ f'{test_type.command} TTFF fails to reach '
+ 'designated criteria')
return ttff_data
def verify_pe(self, mode):
@@ -285,7 +363,7 @@
}
if mode not in ffpe_types:
- raise signals.TestError('Unrecognized mode %s' % mode)
+ raise signals.TestError(f'Unrecognized mode {mode}')
test_type = ffpe_types.get(mode)
ttff_data = self.get_and_verify_ttff(mode)
@@ -294,8 +372,9 @@
ttff_mode=test_type.command,
pe_criteria=test_type.pecriteria)
if not result:
- raise signals.TestFailure('%s TTFF fails to reach '
- 'designated criteria' % test_type.command)
+ raise signals.TestFailure(
+ f'{test_type.command} TTFF fails to reach '
+ 'designated criteria')
return ttff_data
def clear_gps_log(self):
@@ -303,9 +382,77 @@
Delete the existing GPS GTW Log from DUT.
"""
- self.dut.adb.shell("rm -rf {}".format(DEVICE_GPSLOG_FOLDER))
+ self.dut.adb.shell(f'rm -rf {DEVICE_GPSLOG_FOLDER}')
- def gnss_ttff_ffpe(self, mode, sub_context_path=''):
+ def start_dut_gnss_log(self):
+ """Start GNSS chip log according to different diag_option"""
+ # Start GNSS chip log
+ if self.diag_option == "QCOM":
+ diaglog.start_diagmdlog_background(self.dut, maskfile=self.maskfile)
+ else:
+ gutils.start_pixel_logger(self.dut)
+
+ def stop_and_pull_dut_gnss_log(self, gnss_vendor_log_path=None):
+ """
+ Stop DUT GNSS logger and pull log into local PC dir
+ Arg:
+ gnss_vendor_log_path: gnss log path directory.
+ Type, str.
+ Default, None
+ """
+ if not gnss_vendor_log_path:
+ gnss_vendor_log_path = self.gnss_log_path
+ if self.diag_option == "QCOM":
+ diaglog.stop_background_diagmdlog(self.dut,
+ gnss_vendor_log_path,
+ keep_logs=False)
+ else:
+ gutils.stop_pixel_logger(self.dut)
+ self.log.info('Getting Pixel BCM Log!')
+ diaglog.get_pixellogger_bcm_log(self.dut,
+ gnss_vendor_log_path,
+ keep_logs=False)
+
+ def start_gnss_and_wait(self, wait=60):
+ """
+ The process of enable gnss and spend the wait time for GNSS to
+ gather enoung information that make sure the stability of testing.
+
+ Args:
+ wait: wait time between power sweep.
+ Type, int.
+ Default, 60.
+ """
+ # Create log path for waiting section logs of GPStool.
+ gnss_wait_log_dir = os.path.join(self.gnss_log_path, 'GNSS_wait')
+
+ # Enable GNSS to receive satellites' signals for "wait_between_pwr" seconds.
+ self.log.info('Enable GNSS for searching satellites')
+ gutils.start_gnss_by_gtw_gpstool(self.dut, state=True)
+ self.log.info(f'Wait for {wait} seconds')
+ time.sleep(wait)
+
+ # Stop GNSS and pull the logs.
+ gutils.start_gnss_by_gtw_gpstool(self.dut, state=False)
+ diaglog.get_gpstool_logs(self.dut, gnss_wait_log_dir, False)
+
+ def exe_eecoexer_loop_cmd(self, cmd_list=None):
+ """
+ Function for execute EECoexer command list
+ Args:
+ cmd_list: a list of EECoexer function command.
+ Type, list.
+ """
+ if cmd_list:
+ for cmd in cmd_list:
+ self.log.info('Execute EEcoexer Command: {}'.format(cmd))
+ gutils.execute_eecoexer_function(self.dut, cmd)
+
+ def gnss_ttff_ffpe(self,
+ mode,
+ sub_context_path='',
+ coex_cmd='',
+ stop_coex_cmd=''):
"""
Base ttff and ffpe function
Args:
@@ -317,16 +464,24 @@
full_output_path = get_current_context().get_full_output_path()
self.gnss_log_path = os.path.join(full_output_path, sub_context_path)
os.makedirs(self.gnss_log_path, exist_ok=True)
- self.log.debug('Create log path: {}'.format(self.gnss_log_path))
+ self.log.debug(f'Create log path: {self.gnss_log_path}')
# Start and set GNSS simulator
- self.start_and_set_gnss_simulator_power()
+ self.start_set_gnss_power()
# Start GNSS chip log
- if self.diag_option == "QCOM":
- diaglog.start_diagmdlog_background(self.dut, maskfile=self.maskfile)
+ self.start_dut_gnss_log()
+
+ # Wait for acquiring almanac
+ if mode != 'cs':
+ wait_time = 900
else:
- gutils.start_pixel_logger(self.dut)
+ wait_time = 3
+ self.start_gnss_and_wait(wait=wait_time)
+
+ # Start Coex if available
+ if coex_cmd and stop_coex_cmd:
+ self.exe_eecoexer_loop_cmd(coex_cmd)
# Start verifying TTFF and FFPE
self.verify_pe(mode)
@@ -337,13 +492,8 @@
os.makedirs(gnss_vendor_log_path, exist_ok=True)
# Stop GNSS chip log and pull the logs to local file system
- if self.diag_option == "QCOM":
- diaglog.stop_background_diagmdlog(self.dut,
- gnss_vendor_log_path,
- keep_logs=False)
- else:
- gutils.stop_pixel_logger(self.dut)
- self.log.info('Getting Pixel BCM Log!')
- diaglog.get_pixellogger_bcm_log(self.dut,
- gnss_vendor_log_path,
- keep_logs=False)
+ self.stop_and_pull_dut_gnss_log(gnss_vendor_log_path)
+
+ # Stop Coex if available
+ if coex_cmd and stop_coex_cmd:
+ self.exe_eecoexer_loop_cmd(stop_coex_cmd)
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnss_constant.py b/acts_tests/acts_contrib/test_utils/gnss/gnss_constant.py
new file mode 100644
index 0000000..c7835ac
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnss_constant.py
@@ -0,0 +1 @@
+TTFF_MODE = {"cs": "Cold Start", "ws": "Warm Start", "hs": "Hot Start", "csa": "CSWith Assist"}
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnss_measurement.py b/acts_tests/acts_contrib/test_utils/gnss/gnss_measurement.py
new file mode 100644
index 0000000..a9f9579
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnss_measurement.py
@@ -0,0 +1,208 @@
+import os
+import pathlib
+import re
+import shutil
+import tempfile
+from collections import defaultdict
+
+
+class AdrInfo:
+ """Represent one ADR value
+ An ADR value is a decimal number range from 0 - 31
+
+ How to parse the ADR value:
+ First, transform the decimal number to binary then we will get a 5 bit number
+ The meaning of each bit is as follow:
+ 0 0 0 0 0
+ HalfCycleReported HalfCycleResolved CycleSlip Reset Valid
+ Special rule:
+ For an ADR value in binary fits the pattern: * * 0 0 1, we call it a usable ADR
+ More insight of ADR value:
+ go/adrstates
+
+ Attributes:
+ is_valid: (bool)
+ is_reset: (bool)
+ is_cycle_slip: (bool)
+ is_half_cycle_resolved: (bool)
+ is_half_cycle_reported: (bool)
+ is_usable: (bool)
+ """
+ def __init__(self, adr_value: int, count: int):
+ src = bin(int(adr_value))
+ self._valid = int(src[-1])
+ self._reset = int(src[-2])
+ self._cycle_slip = int(src[-3])
+ self._half_cycle_resolved = int(src[-4])
+ self._half_cycle_reported = int(src[-5])
+ self.count = count
+
+ @property
+ def is_usable(self):
+ return self.is_valid and not self.is_reset and not self.is_cycle_slip
+
+ @property
+ def is_valid(self):
+ return bool(self._valid)
+
+ @property
+ def is_reset(self):
+ return bool(self._reset)
+
+ @property
+ def is_cycle_slip(self):
+ return bool(self._cycle_slip)
+
+ @property
+ def is_half_cycle_resolved(self):
+ return bool(self._half_cycle_resolved)
+
+ @property
+ def is_half_cycle_reported(self):
+ return bool(self._half_cycle_reported)
+
+
+class AdrStatistic:
+ """Represent the ADR statistic
+
+ Attributes:
+ usable_count: (int)
+ valid_count: (int)
+ reset_count: (int)
+ cycle_slip_count: (int)
+ half_cycle_resolved_count: (int)
+ half_cycle_reported_count: (int)
+ total_count: (int)
+ usable_rate: (float)
+ usable_count / total_count
+ valid_rate: (float)
+ valid_count / total_count
+ """
+ def __init__(self):
+ self.usable_count = 0
+ self.valid_count = 0
+ self.reset_count = 0
+ self.cycle_slip_count = 0
+ self.half_cycle_resolved_count = 0
+ self.half_cycle_reported_count = 0
+ self.total_count = 0
+
+ @property
+ def usable_rate(self):
+ denominator = max(1, self.total_count)
+ result = self.usable_count / denominator
+ return round(result, 3)
+
+ @property
+ def valid_rate(self):
+ denominator = max(1, self.total_count)
+ result = self.valid_count / denominator
+ return round(result, 3)
+
+ def add_adr_info(self, adr_info: AdrInfo):
+ """Add ADR info record to increase the statistic
+
+ Args:
+ adr_info: AdrInfo object
+ """
+ if adr_info.is_valid:
+ self.valid_count += adr_info.count
+ if adr_info.is_reset:
+ self.reset_count += adr_info.count
+ if adr_info.is_cycle_slip:
+ self.cycle_slip_count += adr_info.count
+ if adr_info.is_half_cycle_resolved:
+ self.half_cycle_resolved_count += adr_info.count
+ if adr_info.is_half_cycle_reported:
+ self.half_cycle_reported_count += adr_info.count
+ if adr_info.is_usable:
+ self.usable_count += adr_info.count
+ self.total_count += adr_info.count
+
+
+
+class GnssMeasurement:
+ """Represent the content of measurement file generated by gps tool"""
+
+ FILE_PATTERN = "/storage/emulated/0/Android/data/com.android.gpstool/files/MEAS*.txt"
+
+ def __init__(self, ad):
+ self.ad = ad
+
+ def _generate_local_temp_path(self, file_name="file.txt"):
+ """Generate a file path for temporarily usage
+
+ Returns:
+ string: local file path
+ """
+ folder = tempfile.mkdtemp()
+ file_path = os.path.join(folder, file_name)
+ return file_path
+
+ def _get_latest_measurement_file_path(self):
+ """Get the latest measurement file path on device
+
+ Returns:
+ string: file path on device
+ """
+ command = f"ls -tr {self.FILE_PATTERN} | tail -1"
+ result = self.ad.adb.shell(command)
+ return result
+
+ def get_latest_measurement_file(self):
+ """Pull the latest measurement file from device to local
+
+ Returns:
+ string: local file path to the measurement file
+
+ Raise:
+ FileNotFoundError: can't get measurement file from device
+ """
+ self.ad.log.info("Get measurement file from device")
+ dest = self._generate_local_temp_path(file_name="measurement.txt")
+ src = self._get_latest_measurement_file_path()
+ if not src:
+ raise FileNotFoundError(f"Can not find measurement file: pattern {self.FILE_PATTERN}")
+ self.ad.pull_files(src, dest)
+ return dest
+
+ def _get_adr_src_value(self):
+ """Get ADR value from measurement file
+
+ Returns:
+ dict: {<ADR_value>: count, <ADR_value>: count...}
+ """
+ try:
+ file_path = self.get_latest_measurement_file()
+ adr_src = defaultdict(int)
+ adr_src_regex = re.compile("=\s(\d*)")
+ with open(file_path) as f:
+ for line in f:
+ if "AccumulatedDeltaRangeState" in line:
+ value = re.search(adr_src_regex, line)
+ if not value:
+ self.ad.log.warn("Can't get ADR value %s" % line)
+ continue
+ key = value.group(1)
+ adr_src[key] += 1
+ return adr_src
+ finally:
+ folder = pathlib.PurePosixPath(file_path).parent
+ shutil.rmtree(folder, ignore_errors=True)
+
+ def get_adr_static(self):
+ """Get ADR statistic
+
+ Summarize ADR value from measurement file
+
+ Returns:
+ AdrStatistic object
+ """
+ self.ad.log.info("Get ADR statistic")
+ adr_src = self._get_adr_src_value()
+ adr_static = AdrStatistic()
+ for key, value in adr_src.items():
+ self.ad.log.debug("ADR value: %s - count: %s" % (key, value))
+ adr_info = AdrInfo(key, value)
+ adr_static.add_adr_info(adr_info)
+ return adr_static
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnss_test_utils.py b/acts_tests/acts_contrib/test_utils/gnss/gnss_test_utils.py
index 5efa817..ec9ba61 100644
--- a/acts_tests/acts_contrib/test_utils/gnss/gnss_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnss_test_utils.py
@@ -13,31 +13,39 @@
# 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 re
import os
+import pathlib
import math
import shutil
import fnmatch
import posixpath
+import subprocess
import tempfile
-import zipfile
+from retry import retry
from collections import namedtuple
from datetime import datetime
from xml.etree import ElementTree
+from contextlib import contextmanager
+from statistics import median
from acts import utils
from acts import asserts
from acts import signals
from acts.libs.proc import job
+from acts.controllers.adb_lib.error import AdbCommandError
from acts.controllers.android_device import list_adb_devices
from acts.controllers.android_device import list_fastboot_devices
from acts.controllers.android_device import DEFAULT_QXDM_LOG_PATH
from acts.controllers.android_device import SL4A_APK_NAME
+from acts_contrib.test_utils.gnss.gnss_measurement import GnssMeasurement
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.tel import tel_logging_utils as tlutils
from acts_contrib.test_utils.tel import tel_test_utils as tutils
+from acts_contrib.test_utils.gnss import gnssstatus_utils
+from acts_contrib.test_utils.gnss import gnss_constant
+from acts_contrib.test_utils.gnss import supl
from acts_contrib.test_utils.instrumentation.device.command.instrumentation_command_builder import InstrumentationCommandBuilder
from acts_contrib.test_utils.instrumentation.device.command.instrumentation_command_builder import InstrumentationTestCommandBuilder
from acts.utils import get_current_epoch_time
@@ -46,6 +54,8 @@
from acts_contrib.test_utils.gnss.gnss_defines import BCM_NVME_STO_PATH
WifiEnums = wutils.WifiEnums
+FIRST_FIXED_MAX_WAITING_TIME = 60
+UPLOAD_TO_SPONGE_PREFIX = "TestResult "
PULL_TIMEOUT = 300
GNSSSTATUS_LOG_PATH = (
"/storage/emulated/0/Android/data/com.android.gpstool/files/")
@@ -54,7 +64,7 @@
"TTFF_REPORT", "utc_time ttff_loop ttff_sec ttff_pe ttff_ant_cn "
"ttff_base_cn ttff_haccu")
TRACK_REPORT = namedtuple(
- "TRACK_REPORT", "l5flag pe ant_top4cn ant_cn base_top4cn base_cn")
+ "TRACK_REPORT", "l5flag pe ant_top4cn ant_cn base_top4cn base_cn device_time report_time")
LOCAL_PROP_FILE_CONTENTS = """\
log.tag.LocationManagerService=VERBOSE
log.tag.GnssLocationProvider=VERBOSE
@@ -70,6 +80,11 @@
log.tag.GnssPsdsDownloader=VERBOSE
log.tag.Gnss=VERBOSE
log.tag.GnssConfiguration=VERBOSE"""
+LOCAL_PROP_FILE_CONTENTS_FOR_WEARABLE = """\
+log.tag.ImsPhone=VERBOSE
+log.tag.GsmCdmaPhone=VERBOSE
+log.tag.Phone=VERBOSE
+log.tag.GCoreFlp=VERBOSE"""
TEST_PACKAGE_NAME = "com.google.android.apps.maps"
LOCATION_PERMISSIONS = [
"android.permission.ACCESS_FINE_LOCATION",
@@ -99,6 +114,7 @@
XTRA_SERVER_2="http://"
XTRA_SERVER_3="http://"
"""
+_BRCM_DUTY_CYCLE_PATTERN = re.compile(r".*PGLOR,\d+,STA.*")
class GnssTestUtilsError(Exception):
@@ -129,7 +145,8 @@
ad: An AndroidDevice object.
"""
ad.log.info("Reboot device to make changes take effect.")
- ad.reboot()
+ # TODO(diegowchung): remove the timeout setting after p23 back to normal
+ ad.reboot(timeout=600)
ad.unlock_screen(password=None)
if not is_mobile_data_on(ad):
set_mobile_data(ad, True)
@@ -149,7 +166,11 @@
else:
ad.adb.shell("echo LogEnabled=true >> /data/vendor/gps/libgps.conf")
ad.adb.shell("chown gps.system /data/vendor/gps/libgps.conf")
- ad.adb.shell("echo %r >> /data/local.prop" % LOCAL_PROP_FILE_CONTENTS)
+ if is_device_wearable(ad):
+ PROP_CONTENTS = LOCAL_PROP_FILE_CONTENTS + LOCAL_PROP_FILE_CONTENTS_FOR_WEARABLE
+ else:
+ PROP_CONTENTS = LOCAL_PROP_FILE_CONTENTS
+ ad.adb.shell("echo %r >> /data/local.prop" % PROP_CONTENTS)
ad.adb.shell("chmod 644 /data/local.prop")
ad.adb.shell("setprop persist.logd.logpersistd.size 20000")
ad.adb.shell("setprop persist.logd.size 16777216")
@@ -221,12 +242,6 @@
remount_device(ad)
ad.log.info("Enable SUPL mode.")
ad.adb.shell("echo -e '\nSUPL_MODE=1' >> /etc/gps_debug.conf")
- if is_device_wearable(ad):
- lto_mode_wearable(ad, True)
- elif not check_chipset_vendor_by_qualcomm(ad):
- lto_mode(ad, True)
- else:
- reboot(ad)
def disable_supl_mode(ad):
@@ -238,16 +253,33 @@
remount_device(ad)
ad.log.info("Disable SUPL mode.")
ad.adb.shell("echo -e '\nSUPL_MODE=0' >> /etc/gps_debug.conf")
+ if not check_chipset_vendor_by_qualcomm(ad):
+ supl.set_supl_over_wifi_state(ad, False)
+
+
+def enable_vendor_orbit_assistance_data(ad):
+ """Enable vendor assistance features.
+ For Qualcomm: Enable XTRA
+ For Broadcom: Enable LTO
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ ad.root_adb()
if is_device_wearable(ad):
lto_mode_wearable(ad, True)
- elif not check_chipset_vendor_by_qualcomm(ad):
- lto_mode(ad, True)
- else:
+ elif check_chipset_vendor_by_qualcomm(ad):
+ disable_xtra_throttle(ad)
reboot(ad)
+ else:
+ lto_mode(ad, True)
-def kill_xtra_daemon(ad):
- """Kill XTRA daemon to test SUPL only test item.
+def disable_vendor_orbit_assistance_data(ad):
+ """Disable vendor assistance features.
+
+ For Qualcomm: disable XTRA
+ For Broadcom: disable LTO
Args:
ad: An AndroidDevice object.
@@ -256,11 +288,41 @@
if is_device_wearable(ad):
lto_mode_wearable(ad, False)
elif check_chipset_vendor_by_qualcomm(ad):
- ad.log.info("Disable XTRA-daemon until next reboot.")
- ad.adb.shell("killall xtra-daemon", ignore_status=True)
+ disable_qualcomm_orbit_assistance_data(ad)
else:
lto_mode(ad, False)
+def gla_mode(ad, state: bool):
+ """Enable or disable Google Location Accuracy feature.
+
+ Args:
+ ad: An AndroidDevice object.
+ state: True to enable GLA, False to disable GLA.
+ """
+ ad.root_adb()
+ if state:
+ ad.adb.shell('settings put global assisted_gps_enabled 1')
+ ad.log.info("Modify current GLA Mode to MS_BASED mode")
+ else:
+ ad.adb.shell('settings put global assisted_gps_enabled 0')
+ ad.log.info("Modify current GLA Mode to standalone mode")
+
+ out = int(ad.adb.shell("settings get global assisted_gps_enabled"))
+ if out == 1:
+ ad.log.info("GLA is enabled, MS_BASED mode")
+ else:
+ ad.log.info("GLA is disabled, standalone mode")
+
+
+def disable_qualcomm_orbit_assistance_data(ad):
+ """Disable assiatance features for Qualcomm project.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ ad.log.info("Disable XTRA-daemon until next reboot.")
+ ad.adb.shell("killall xtra-daemon", ignore_status=True)
+
def disable_private_dns_mode(ad):
"""Due to b/118365122, it's better to disable private DNS mode while
@@ -282,26 +344,17 @@
Args:
ad: An AndroidDevice object.
"""
+ check_location_service(ad)
enable_gnss_verbose_logging(ad)
- enable_compact_and_particle_fusion_log(ad)
prepare_gps_overlay(ad)
- if check_chipset_vendor_by_qualcomm(ad):
- disable_xtra_throttle(ad)
- enable_supl_mode(ad)
- if is_device_wearable(ad):
- ad.adb.shell("settings put global stay_on_while_plugged_in 7")
- else:
- ad.adb.shell("settings put system screen_off_timeout 1800000")
- wutils.wifi_toggle_state(ad, False)
+ set_screen_always_on(ad)
ad.log.info("Setting Bluetooth state to False")
ad.droid.bluetoothToggleState(False)
- check_location_service(ad)
set_wifi_and_bt_scanning(ad, True)
disable_private_dns_mode(ad)
- reboot(ad)
init_gtw_gpstool(ad)
- if not is_mobile_data_on(ad):
- set_mobile_data(ad, True)
+ if is_device_wearable(ad):
+ disable_battery_defend(ad)
def prepare_gps_overlay(ad):
@@ -368,8 +421,14 @@
ad.ed.clear_all_events()
wutils.reset_wifi(ad)
wutils.start_wifi_connection_scan_and_ensure_network_found(ad, SSID)
- wutils.wifi_connect(ad, network, num_of_tries=5)
-
+ for i in range(5):
+ wutils.wifi_connect(ad, network, check_connectivity=False)
+ # Validates wifi connection with ping_gateway=False to avoid issue like
+ # b/254913994.
+ if wutils.validate_connection(ad, ping_gateway=False):
+ ad.log.info("WiFi connection is validated")
+ return
+ raise signals.TestError("Failed to connect WiFi")
def set_wifi_and_bt_scanning(ad, state=True):
"""Set Wi-Fi and Bluetooth scanning on/off in Settings -> Location
@@ -406,6 +465,22 @@
raise signals.TestError("Failed to turn Location on")
+def delete_device_folder(ad, folder):
+ ad.log.info("Folder to be deleted: %s" % folder)
+ folder_contents = ad.adb.shell(f"ls {folder}", ignore_status=True)
+ ad.log.debug("Contents to be deleted: %s" % folder_contents)
+ ad.adb.shell("rm -rf %s" % folder, ignore_status=True)
+
+
+def remove_pixel_logger_folder(ad):
+ if check_chipset_vendor_by_qualcomm(ad):
+ folder = "/sdcard/Android/data/com.android.pixellogger/files/logs/diag_logs"
+ else:
+ folder = "/sdcard/Android/data/com.android.pixellogger/files/logs/gps/"
+
+ delete_device_folder(ad, folder)
+
+
def clear_logd_gnss_qxdm_log(ad):
"""Clear /data/misc/logd,
/storage/emulated/0/Android/data/com.android.gpstool/files and
@@ -416,20 +491,21 @@
"""
remount_device(ad)
ad.log.info("Clear Logd, GNSS and PixelLogger Log from previous test item.")
- ad.adb.shell("rm -rf /data/misc/logd", ignore_status=True)
+ folders_should_be_removed = ["/data/misc/logd"]
ad.adb.shell(
'find %s -name "*.txt" -type f -delete' % GNSSSTATUS_LOG_PATH,
ignore_status=True)
if check_chipset_vendor_by_qualcomm(ad):
- diag_logs = (
- "/sdcard/Android/data/com.android.pixellogger/files/logs/diag_logs")
- ad.adb.shell("rm -rf %s" % diag_logs, ignore_status=True)
output_path = posixpath.join(DEFAULT_QXDM_LOG_PATH, "logs")
+ folders_should_be_removed += [output_path]
else:
- output_path = ("/sdcard/Android/data/com.android.pixellogger/files"
- "/logs/gps/")
- ad.adb.shell("rm -rf %s" % output_path, ignore_status=True)
- reboot(ad)
+ always_on_logger_log_path = ("/data/vendor/gps/logs")
+ folders_should_be_removed += [always_on_logger_log_path]
+ for folder in folders_should_be_removed:
+ delete_device_folder(ad, folder)
+ remove_pixel_logger_folder(ad)
+ if not is_device_wearable(ad):
+ reboot(ad)
def get_gnss_qxdm_log(ad, qdb_path=None):
@@ -589,14 +665,13 @@
ad.log.info("XTRA downloaded and injected successfully.")
return True
ad.log.error("XTRA downloaded FAIL.")
- elif is_device_wearable(ad):
- lto_results = ad.adb.shell("ls -al /data/vendor/gps/lto*")
- if "lto2.dat" in lto_results:
- ad.log.info("LTO downloaded and injected successfully.")
- return True
else:
- lto_results = ad.search_logcat("GnssPsdsAidl: injectPsdsData: "
- "psdsType: 1", begin_time)
+ if is_device_wearable(ad):
+ lto_results = ad.search_logcat("GnssLocationProvider: "
+ "calling native_inject_psds_data", begin_time)
+ else:
+ lto_results = ad.search_logcat("GnssPsdsAidl: injectPsdsData: "
+ "psdsType: 1", begin_time)
if lto_results:
ad.log.debug("%s" % lto_results[-1]["log_message"])
ad.log.info("LTO downloaded and injected successfully.")
@@ -776,7 +851,7 @@
def start_gnss_by_gtw_gpstool(ad,
state,
- type="gnss",
+ api_type="gnss",
bgdisplay=False,
freq=0,
lowpower=False,
@@ -786,7 +861,7 @@
Args:
ad: An AndroidDevice object.
state: True to start GNSS. False to Stop GNSS.
- type: Different API for location fix. Use gnss/flp/nmea
+ api_type: Different API for location fix. Use gnss/flp/nmea
bgdisplay: true to run GTW when Display off. false to not run GTW when
Display off.
freq: An integer to set location update frequency.
@@ -795,36 +870,42 @@
"""
cmd = "am start -S -n com.android.gpstool/.GPSTool --es mode gps"
if not state:
- ad.log.info("Stop %s on GTW_GPSTool." % type)
+ ad.log.info("Stop %s on GTW_GPSTool." % api_type)
cmd = "am broadcast -a com.android.gpstool.stop_gps_action"
else:
options = ("--es type {} --ei freq {} --ez BG {} --ez meas {} --ez "
- "lowpower {}").format(type, freq, bgdisplay, meas, lowpower)
+ "lowpower {}").format(api_type, freq, bgdisplay, meas, lowpower)
cmd = cmd + " " + options
- ad.adb.shell(cmd)
+ ad.adb.shell(cmd, ignore_status=True, timeout = 300)
time.sleep(3)
def process_gnss_by_gtw_gpstool(ad,
criteria,
- type="gnss",
+ api_type="gnss",
clear_data=True,
- meas_flag=False):
+ meas_flag=False,
+ freq=0,
+ bg_display=False):
"""Launch GTW GPSTool and Clear all GNSS aiding data
Start GNSS tracking on GTW_GPSTool.
Args:
ad: An AndroidDevice object.
criteria: Criteria for current test item.
- type: Different API for location fix. Use gnss/flp/nmea
+ api_type: Different API for location fix. Use gnss/flp/nmea
clear_data: True to clear GNSS aiding data. False is not to. Default
set to True.
meas_flag: True to enable GnssMeasurement. False is not to. Default
set to False.
+ freq: An integer to set location update frequency. Default set to 0.
+ bg_display: To enable GPS tool bg display or not
Returns:
- True: First fix TTFF are within criteria.
- False: First fix TTFF exceed criteria.
+ First fix datetime obj
+
+ Raises:
+ signals.TestFailure: when first fixed is over criteria or not even get first fixed
"""
retries = 3
for i in range(retries):
@@ -836,27 +917,28 @@
begin_time = get_current_epoch_time()
if clear_data:
clear_aiding_data_by_gtw_gpstool(ad)
- ad.log.info("Start %s on GTW_GPSTool - attempt %d" % (type.upper(),
+ ad.log.info("Start %s on GTW_GPSTool - attempt %d" % (api_type.upper(),
i+1))
- start_gnss_by_gtw_gpstool(ad, state=True, type=type, meas=meas_flag)
+ start_gnss_by_gtw_gpstool(ad, state=True, api_type=api_type, meas=meas_flag, freq=freq,
+ bgdisplay=bg_display)
for _ in range(10 + criteria):
logcat_results = ad.search_logcat("First fixed", begin_time)
if logcat_results:
ad.log.debug(logcat_results[-1]["log_message"])
first_fixed = int(logcat_results[-1]["log_message"].split()[-1])
ad.log.info("%s First fixed = %.3f seconds" %
- (type.upper(), first_fixed/1000))
+ (api_type.upper(), first_fixed/1000))
if (first_fixed/1000) <= criteria:
- return True
- start_gnss_by_gtw_gpstool(ad, state=False, type=type)
+ return logcat_results[-1]["datetime_obj"]
+ start_gnss_by_gtw_gpstool(ad, state=False, api_type=api_type)
raise signals.TestFailure("Fail to get %s location fixed "
"within %d seconds criteria."
- % (type.upper(), criteria))
+ % (api_type.upper(), criteria))
time.sleep(1)
check_current_focus_app(ad)
- start_gnss_by_gtw_gpstool(ad, state=False, type=type)
+ start_gnss_by_gtw_gpstool(ad, state=False, api_type=api_type)
raise signals.TestFailure("Fail to get %s location fixed within %d "
- "attempts." % (type.upper(), retries))
+ "attempts." % (api_type.upper(), retries))
def start_ttff_by_gtw_gpstool(ad,
@@ -866,7 +948,8 @@
raninterval=False,
mininterval=10,
maxinterval=40,
- hot_warm_sleep=300):
+ hot_warm_sleep=300,
+ timeout=60):
"""Identify which TTFF mode for different test items.
Args:
@@ -878,8 +961,12 @@
mininterval: Minimum value of random interval pool. The unit is second.
maxinterval: Maximum value of random interval pool. The unit is second.
hot_warm_sleep: Wait time for acquiring Almanac.
+ timeout: TTFF time out. The unit is second.
+ Returns:
+ latest_start_time: (Datetime) the start time of latest successful TTFF
"""
begin_time = get_current_epoch_time()
+ ad.log.debug("[start_ttff] Search logcat start time: %s" % begin_time)
if (ttff_mode == "hs" or ttff_mode == "ws") and not aid_data:
ad.log.info("Wait {} seconds to start TTFF {}...".format(
hot_warm_sleep, ttff_mode.upper()))
@@ -891,16 +978,32 @@
ad.log.info("Start TTFF CSWith Assist...")
time.sleep(3)
for i in range(1, 4):
- ad.adb.shell("am broadcast -a com.android.gpstool.ttff_action "
- "--es ttff {} --es cycle {} --ez raninterval {} "
- "--ei mininterval {} --ei maxinterval {}".format(
+ try:
+ ad.log.info(f"Before sending TTFF gms version is {get_gms_version(ad)}")
+ ad.adb.shell("am broadcast -a com.android.gpstool.ttff_action "
+ "--es ttff {} --es cycle {} --ez raninterval {} "
+ "--ei mininterval {} --ei maxinterval {}".format(
ttff_mode, iteration, raninterval, mininterval,
maxinterval))
+ except job.TimeoutError:
+ # If this is the last retry and we still get timeout error, raises the timeoutError.
+ if i == 3:
+ raise
+ # Currently we encounter lots of timeout issue in Qualcomm devices. But so far we don't
+ # know the root cause yet. In order to continue the test, we ignore the timeout for
+ # retry.
+ ad.log.warn("Send TTFF command timeout.")
+ ad.log.info(f"Current gms version is {get_gms_version(ad)}")
+ # Wait 2 second to retry
+ time.sleep(2)
+ continue
time.sleep(1)
- if ad.search_logcat("act=com.android.gpstool.start_test_action",
- begin_time):
+ result = ad.search_logcat("act=com.android.gpstool.start_test_action", begin_time)
+ if result:
+ ad.log.debug("TTFF start log %s" % result)
+ latest_start_time = max(list(map(lambda x: x['datetime_obj'], result)))
ad.log.info("Send TTFF start_test_action successfully.")
- break
+ return latest_start_time
else:
check_current_focus_app(ad)
raise signals.TestError("Fail to send TTFF start_test_action.")
@@ -908,31 +1011,73 @@
def gnss_tracking_via_gtw_gpstool(ad,
criteria,
- type="gnss",
+ api_type="gnss",
testtime=60,
- meas_flag=False):
+ meas_flag=False,
+ freq=0,
+ is_screen_off=False):
"""Start GNSS/FLP tracking tests for input testtime on GTW_GPSTool.
Args:
ad: An AndroidDevice object.
criteria: Criteria for current TTFF.
- type: Different API for location fix. Use gnss/flp/nmea
+ api_type: Different API for location fix. Use gnss/flp/nmea
testtime: Tracking test time for minutes. Default set to 60 minutes.
meas_flag: True to enable GnssMeasurement. False is not to. Default
set to False.
+ freq: An integer to set location update frequency. Default set to 0.
+ is_screen_off: whether to turn off during tracking
"""
process_gnss_by_gtw_gpstool(
- ad, criteria=criteria, type=type, meas_flag=meas_flag)
- ad.log.info("Start %s tracking test for %d minutes" % (type.upper(),
+ ad, criteria=criteria, api_type=api_type, meas_flag=meas_flag, freq=freq,
+ bg_display=is_screen_off)
+ ad.log.info("Start %s tracking test for %d minutes" % (api_type.upper(),
testtime))
begin_time = get_current_epoch_time()
+ with set_screen_status(ad, off=is_screen_off):
+ wait_n_mins_for_gnss_tracking(ad, begin_time, testtime, api_type)
+ ad.log.info("Successfully tested for %d minutes" % testtime)
+ start_gnss_by_gtw_gpstool(ad, state=False, api_type=api_type)
+
+
+def wait_n_mins_for_gnss_tracking(ad, begin_time, testtime, api_type="gnss",
+ ignore_hal_crash=False):
+ """Waits for GNSS tracking to finish and detect GNSS crash during the waiting time.
+
+ Args:
+ ad: An AndroidDevice object.
+ begin_time: The start time of tracking.
+ api_type: Different API for location fix. Use gnss/flp/nmea
+ testtime: Tracking test time for minutes.
+ ignore_hal_crash: To ignore HAL crash error no not.
+ """
while get_current_epoch_time() - begin_time < testtime * 60 * 1000:
- detect_crash_during_tracking(ad, begin_time, type)
- ad.log.info("Successfully tested for %d minutes" % testtime)
- start_gnss_by_gtw_gpstool(ad, state=False, type=type)
+ detect_crash_during_tracking(ad, begin_time, api_type, ignore_hal_crash)
+ # add sleep here to avoid too many request and cause device not responding
+ time.sleep(1)
+def run_ttff_via_gtw_gpstool(ad, mode, criteria, test_cycle, true_location):
+ """Run GNSS TTFF test with selected mode and parse the results.
-def parse_gtw_gpstool_log(ad, true_position, type="gnss"):
+ Args:
+ mode: "cs", "ws" or "hs"
+ criteria: Criteria for the TTFF.
+
+ Returns:
+ ttff_data: A dict of all TTFF data.
+ """
+ # Before running TTFF, we will run tracking and try to get first fixed.
+ # But the TTFF before TTFF doesn't apply to any criteria, so we set a maximum value.
+ process_gnss_by_gtw_gpstool(ad, criteria=FIRST_FIXED_MAX_WAITING_TIME)
+ ttff_start_time = start_ttff_by_gtw_gpstool(ad, mode, test_cycle)
+ ttff_data = process_ttff_by_gtw_gpstool(ad, ttff_start_time, true_location)
+ result = check_ttff_data(ad, ttff_data, gnss_constant.TTFF_MODE.get(mode), criteria)
+ asserts.assert_true(
+ result, "TTFF %s fails to reach designated criteria: %d "
+ "seconds." % (gnss_constant.TTFF_MODE.get(mode), criteria))
+ return ttff_data
+
+def parse_gtw_gpstool_log(ad, true_position, api_type="gnss", validate_gnssstatus=False):
"""Process GNSS/FLP API logs from GTW GPSTool and output track_data to
test_run_info for ACTS plugin to parse and display on MobileHarness as
Property.
@@ -941,8 +1086,14 @@
ad: An AndroidDevice object.
true_position: Coordinate as [latitude, longitude] to calculate
position error.
- type: Different API for location fix. Use gnss/flp/nmea
+ api_type: Different API for location fix. Use gnss/flp/nmea
+ validate_gnssstatus: Validate gnssstatus or not
+
+ Returns:
+ A dict of location reported from GPSTool
+ {<utc_time>: TRACK_REPORT, ...}
"""
+ gnssstatus_count = 0
test_logfile = {}
track_data = {}
ant_top4_cn = 0
@@ -952,11 +1103,13 @@
track_lat = 0
track_long = 0
l5flag = "false"
+ gps_datetime_pattern = re.compile("(\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\.\d{0,5})")
+ gps_datetime_format = "%Y/%m/%d %H:%M:%S.%f"
file_count = int(ad.adb.shell("find %s -type f -iname *.txt | wc -l"
% GNSSSTATUS_LOG_PATH))
if file_count != 1:
- ad.log.error("%d API logs exist." % file_count)
- dir_file = ad.adb.shell("ls %s" % GNSSSTATUS_LOG_PATH).split()
+ ad.log.warn("%d API logs exist." % file_count)
+ dir_file = ad.adb.shell("ls -tr %s" % GNSSSTATUS_LOG_PATH).split()
for path_key in dir_file:
if fnmatch.fnmatch(path_key, "*.txt"):
logpath = posixpath.join(GNSSSTATUS_LOG_PATH, path_key)
@@ -970,7 +1123,20 @@
if not test_logfile:
raise signals.TestError("Failed to get test log file in device.")
lines = ad.adb.shell("cat %s" % test_logfile).split("\n")
+ gnss_svid_container = gnssstatus_utils.GnssSvidContainer()
for line in lines:
+ if line.startswith('Fix'):
+ try:
+ gnss_status = gnssstatus_utils.GnssStatus(line)
+ gnssstatus_count += 1
+ except gnssstatus_utils.RegexParseException as e:
+ ad.log.warn(e)
+ continue
+
+ gnss_svid_container.add_satellite(gnss_status)
+ if validate_gnssstatus:
+ gnss_status.validate_gnssstatus()
+
if "Antenna_History Avg Top4" in line:
ant_top4_cn = float(line.split(":")[-1].strip())
elif "Antenna_History Avg" in line:
@@ -985,8 +1151,13 @@
track_lat = float(line.split(":")[-1].strip())
elif "Longitude" in line:
track_long = float(line.split(":")[-1].strip())
+ elif "Read:" in line:
+ target = re.search(gps_datetime_pattern, line)
+ device_time = datetime.strptime(target.group(1), gps_datetime_format)
elif "Time" in line:
- track_utc = line.split("Time:")[-1].strip()
+ target = re.search(gps_datetime_pattern, line)
+ track_utc = target.group(1)
+ report_time = datetime.strptime(track_utc, gps_datetime_format)
if track_utc in track_data.keys():
continue
pe = calculate_position_error(track_lat, track_long, true_position)
@@ -995,9 +1166,13 @@
ant_top4cn=ant_top4_cn,
ant_cn=ant_cn,
base_top4cn=base_top4_cn,
- base_cn=base_cn)
+ base_cn=base_cn,
+ device_time=device_time,
+ report_time=report_time,
+ )
+ ad.log.info("Total %d gnssstatus samples verified" %gnssstatus_count)
ad.log.debug(track_data)
- prop_basename = "TestResult %s_tracking_" % type.upper()
+ prop_basename = UPLOAD_TO_SPONGE_PREFIX + f"{api_type.upper()}_tracking_"
time_list = sorted(track_data.keys())
l5flag_list = [track_data[key].l5flag for key in time_list]
pe_list = [float(track_data[key].pe) for key in time_list]
@@ -1016,9 +1191,84 @@
ad.log.info(prop_basename+"Ant_AvgSignal %.1f" % ant_cn_list[-1])
ad.log.info(prop_basename+"Base_AvgTop4Signal %.1f" % base_top4cn_list[-1])
ad.log.info(prop_basename+"Base_AvgSignal %.1f" % base_cn_list[-1])
+ _log_svid_info(gnss_svid_container, prop_basename, ad)
+ return track_data
-def process_ttff_by_gtw_gpstool(ad, begin_time, true_position, type="gnss"):
+def verify_gps_time_should_be_close_to_device_time(ad, tracking_result):
+ """Check the time gap between GPS time and device time.
+
+ In normal cases, the GPS time should be close to device time. But if GPS week rollover happens,
+ the GPS time may goes back to 20 years ago. In order to capture this issue, we assert the time
+ diff between the GPS time and device time.
+
+ Args:
+ ad: The device under test.
+ tracking_result: The result we get from GNSS tracking.
+ """
+ ad.log.info("Validating GPS/Device time difference")
+ max_time_diff_in_seconds = 2.0
+ exceed_report = []
+ for report in tracking_result.values():
+ time_diff_in_seconds = abs((report.report_time - report.device_time).total_seconds())
+ if time_diff_in_seconds > max_time_diff_in_seconds:
+ message = (f"GPS time: {report.report_time} Device time: {report.device_time} "
+ f"diff: {time_diff_in_seconds}")
+ exceed_report.append(message)
+ fail_message = (f"The following items exceed {max_time_diff_in_seconds}s\n" +
+ "\n".join(exceed_report))
+ asserts.assert_false(exceed_report, msg=fail_message)
+
+
+def validate_location_fix_rate(ad, location_reported, run_time, fix_rate_criteria):
+ """Check location reported count
+
+ The formula is "total_fix_points / (run_time * 60)"
+ When the result is lower than fix_rate_criteria, fail the test case
+
+ Args:
+ ad: AndroidDevice object
+ location_reported: (Enumerate) Contains the reported location
+ run_time: (int) How many minutes do we need to verify
+ fix_rate_criteria: The threshold of the pass criteria
+ if we expect fix rate to be 99%, then fix_rate_criteria should be 0.99
+ """
+ ad.log.info("Validating fix rate")
+ pass_criteria = run_time * 60 * fix_rate_criteria
+ actual_location_count = len(location_reported)
+
+ # The fix rate may exceed 100% occasionally, to standardlize the result
+ # set maximum fix rate to 100%
+ actual_fix_rate = min(1, (actual_location_count / (run_time * 60)))
+ actual_fix_rate_percentage = f"{actual_fix_rate:.0%}"
+
+ log_prefix = UPLOAD_TO_SPONGE_PREFIX + f"FIX_RATE_"
+ ad.log.info("%sresult %s" % (log_prefix, actual_fix_rate_percentage))
+ ad.log.debug("Actual location count %s" % actual_location_count)
+
+ fail_message = (f"Fail to meet criteria. Expect to have at least {pass_criteria} location count"
+ f" Actual: {actual_location_count}")
+ asserts.assert_true(pass_criteria <= actual_location_count, msg=fail_message)
+
+
+def _log_svid_info(container, log_prefix, ad):
+ """Write GnssSvidContainer svid information into logger
+ Args:
+ container: A GnssSvidContainer object
+ log_prefix:
+ A prefix used to specify the log will be upload to dashboard
+ ad: An AndroidDevice object
+ """
+ for sv_type, svids in container.used_in_fix.items():
+ message = f"{log_prefix}{sv_type} {len(svids)}"
+ ad.log.info(message)
+ ad.log.debug("Satellite used in fix %s ids are: %s", sv_type, svids)
+
+ for sv_type, svids in container.not_used_in_fix.items():
+ ad.log.debug("Satellite not used in fix %s ids are: %s", sv_type, svids)
+
+
+def process_ttff_by_gtw_gpstool(ad, begin_time, true_position, api_type="gnss"):
"""Process TTFF and record results in ttff_data.
Args:
@@ -1026,7 +1276,7 @@
begin_time: test begin time.
true_position: Coordinate as [latitude, longitude] to calculate
position error.
- type: Different API for location fix. Use gnss/flp/nmea
+ api_type: Different API for location fix. Use gnss/flp/nmea
Returns:
ttff_data: A dict of all TTFF data.
@@ -1051,7 +1301,7 @@
if ttff_sec != 0.0:
ttff_ant_cn = float(ttff_log[18].strip("]"))
ttff_base_cn = float(ttff_log[25].strip("]"))
- if type == "gnss":
+ if api_type == "gnss":
gnss_results = ad.search_logcat("GPSService: Check item",
begin_time)
if gnss_results:
@@ -1067,7 +1317,7 @@
utc_time = epoch_to_human_time(loc_time)
ttff_haccu = float(
gnss_location_log[11].split("=")[-1].strip(","))
- elif type == "flp":
+ elif api_type == "flp":
flp_results = ad.search_logcat("GPSService: FLP Location",
begin_time)
if flp_results:
@@ -1139,11 +1389,13 @@
% (len(ttff_data.keys()), ttff_mode))
ad.log.info("%s PASS criteria is %d seconds" % (ttff_mode, criteria))
ad.log.debug("%s TTFF data: %s" % (ttff_mode, ttff_data))
- ttff_property_key_and_value(ad, ttff_data, ttff_mode)
if len(ttff_data.keys()) == 0:
ad.log.error("GTW_GPSTool didn't process TTFF properly.")
- return False
- elif any(float(ttff_data[key].ttff_sec) == 0.0 for key in ttff_data.keys()):
+ raise ValueError("No ttff loop is done")
+
+ ttff_property_key_and_value(ad, ttff_data, ttff_mode)
+
+ if any(float(ttff_data[key].ttff_sec) == 0.0 for key in ttff_data.keys()):
ad.log.error("One or more TTFF %s Timeout" % ttff_mode)
return False
elif any(float(ttff_data[key].ttff_sec) >= criteria for key in
@@ -1165,6 +1417,7 @@
ttff_data: TTFF data of secs, position error and signal strength.
ttff_mode: TTFF Test mode for current test item.
"""
+ timeout_ttff = 61
prop_basename = "TestResult "+ttff_mode.replace(" ", "_")+"_TTFF_"
sec_list = [float(ttff_data[key].ttff_sec) for key in ttff_data.keys()]
pe_list = [float(ttff_data[key].ttff_pe) for key in ttff_data.keys()]
@@ -1175,12 +1428,14 @@
haccu_list = [float(ttff_data[key].ttff_haccu) for key in
ttff_data.keys()]
timeoutcount = sec_list.count(0.0)
+ sec_list = sorted(sec_list)
if len(sec_list) == timeoutcount:
- avgttff = 9527
+ median_ttff = avgttff = timeout_ttff
else:
avgttff = sum(sec_list)/(len(sec_list) - timeoutcount)
+ median_ttff = median(sec_list)
if timeoutcount != 0:
- maxttff = 9527
+ maxttff = timeout_ttff
else:
maxttff = max(sec_list)
avgdis = sum(pe_list)/len(pe_list)
@@ -1189,6 +1444,7 @@
base_avgcn = sum(base_cn_list)/len(base_cn_list)
avg_haccu = sum(haccu_list)/len(haccu_list)
ad.log.info(prop_basename+"AvgTime %.1f" % avgttff)
+ ad.log.info(prop_basename+"MedianTime %.1f" % median_ttff)
ad.log.info(prop_basename+"MaxTime %.1f" % maxttff)
ad.log.info(prop_basename+"TimeoutCount %d" % timeoutcount)
ad.log.info(prop_basename+"AvgDis %.1f" % avgdis)
@@ -1249,11 +1505,14 @@
Args:
ad: An AndroidDevice object.
+ Returns:
+ string: the current focused window / app
"""
time.sleep(1)
current = ad.adb.shell(
"dumpsys window | grep -E 'mCurrentFocus|mFocusedApp'")
ad.log.debug("\n"+current)
+ return current
def check_location_api(ad, retries):
@@ -1300,7 +1559,8 @@
criteria = criteria * 1000
search_pattern = ("GPSTool : networkLocationType = %s" % location_type)
for i in range(retries):
- begin_time = get_current_epoch_time()
+ # Capture the begin time 1 seconds before due to time gap.
+ begin_time = get_current_epoch_time() - 1000
ad.log.info("Try to get NLP status - attempt %d" % (i+1))
ad.adb.shell(
"am start -S -n com.android.gpstool/.GPSTool --es mode nlp")
@@ -1404,6 +1664,11 @@
"but audio is not in MUSIC state")
+def get_gms_version(ad):
+ cmd = "dumpsys package com.google.android.gms | grep versionName"
+ return ad.adb.shell(cmd).split("\n")[0].split("=")[1]
+
+
def get_baseband_and_gms_version(ad, extra_msg=""):
"""Get current radio baseband and GMSCore version of AndroidDevice object.
@@ -1417,9 +1682,7 @@
try:
build_version = ad.adb.getprop("ro.build.id")
baseband_version = ad.adb.getprop("gsm.version.baseband")
- gms_version = ad.adb.shell(
- "dumpsys package com.google.android.gms | grep versionName"
- ).split("\n")[0].split("=")[1]
+ gms_version = get_gms_version(ad)
if check_chipset_vendor_by_qualcomm(ad):
mpss_version = ad.adb.shell(
"cat /sys/devices/soc0/images | grep MPSS | cut -d ':' -f 3")
@@ -1947,7 +2210,7 @@
raise signals.TestError("Failed to launch EEcoexer.")
-def excute_eecoexer_function(ad, eecoexer_args):
+def execute_eecoexer_function(ad, eecoexer_args):
"""Execute EEcoexer commands.
Args:
@@ -1970,6 +2233,21 @@
ad.adb.shell(wait_for_cmd)
+def get_process_pid(ad, process_name):
+ """Gets the process PID
+
+ Args:
+ ad: The device under test
+ process_name: The name of the process
+
+ Returns:
+ The PID of the process
+ """
+ command = f"ps -A | grep {process_name} | awk '{{print $2}}'"
+ pid = ad.adb.shell(command)
+ return pid
+
+
def restart_gps_daemons(ad):
"""Restart GPS daemons by killing services of gpsd, lhd and scd.
@@ -1979,22 +2257,22 @@
gps_daemons_list = ["gpsd", "lhd", "scd"]
ad.root_adb()
for service in gps_daemons_list:
- begin_time = get_current_epoch_time()
time.sleep(3)
ad.log.info("Kill GPS daemon \"%s\"" % service)
- ad.adb.shell("killall %s" % service)
+ service_pid = get_process_pid(ad, service)
+ ad.log.debug("%s PID: %s" % (service, service_pid))
+ ad.adb.shell(f"kill -9 {service_pid}")
# Wait 3 seconds for daemons and services to start.
time.sleep(3)
- restart_services = ad.search_logcat("starting service", begin_time)
- for restart_service in restart_services:
- if service in restart_service["log_message"]:
- ad.log.info(restart_service["log_message"])
- ad.log.info(
- "GPS daemon \"%s\" restarts successfully." % service)
- break
- else:
+
+ new_pid = get_process_pid(ad, service)
+ ad.log.debug("%s new PID: %s" % (service, new_pid))
+ if not new_pid or service_pid == new_pid:
raise signals.TestError("Unable to restart \"%s\"" % service)
+ ad.log.info("GPS daemon \"%s\" restarts successfully. PID from %s to %s" % (
+ service, service_pid, new_pid))
+
def is_device_wearable(ad):
"""Check device is wearable project or not.
@@ -2044,6 +2322,21 @@
return None
+def _get_dpo_info_from_logcat(ad, begin_time):
+ """Gets the DPO info from logcat.
+
+ Args:
+ ad: The device under test.
+ begin_time: The start time of the log.
+ """
+ dpo_results = ad.search_logcat("HardwareClockDiscontinuityCount",
+ begin_time)
+ if not dpo_results:
+ raise signals.TestError(
+ "No \"HardwareClockDiscontinuityCount\" is found in logs.")
+ return dpo_results
+
+
def check_dpo_rate_via_gnss_meas(ad, begin_time, dpo_threshold):
"""Check DPO engage rate through "HardwareClockDiscontinuityCount" in
GnssMeasurement callback.
@@ -2054,11 +2347,7 @@
dpo_threshold: The value to set threshold. (Ex: dpo_threshold = 60)
"""
time_regex = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{3})'
- dpo_results = ad.search_logcat("HardwareClockDiscontinuityCount",
- begin_time)
- if not dpo_results:
- raise signals.TestError(
- "No \"HardwareClockDiscontinuityCount\" is found in logs.")
+ dpo_results = _get_dpo_info_from_logcat(ad, begin_time)
ad.log.info(dpo_results[0]["log_message"])
ad.log.info(dpo_results[-1]["log_message"])
start_time = re.compile(
@@ -2083,13 +2372,14 @@
threshold))
-def parse_brcm_nmea_log(ad, nmea_pattern, brcm_error_log_allowlist):
+def parse_brcm_nmea_log(ad, nmea_pattern, brcm_error_log_allowlist, stop_logger=True):
"""Parse specific NMEA pattern out of BRCM NMEA log.
Args:
ad: An AndroidDevice object.
nmea_pattern: Specific NMEA pattern to parse.
brcm_error_log_allowlist: Benign error logs to exclude.
+ stop_logger: To stop pixel logger or not.
Returns:
brcm_log_list: A list of specific NMEA pattern logs.
@@ -2097,58 +2387,68 @@
brcm_log_list = []
brcm_log_error_pattern = ["lhd: FS: Start Failsafe dump", "E slog"]
brcm_error_log_list = []
- stop_pixel_logger(ad)
pixellogger_path = (
"/sdcard/Android/data/com.android.pixellogger/files/logs/gps/.")
- tmp_log_path = tempfile.mkdtemp()
- ad.pull_files(pixellogger_path, tmp_log_path)
- for path_key in os.listdir(tmp_log_path):
- zip_path = posixpath.join(tmp_log_path, path_key)
- if path_key.endswith(".zip"):
- ad.log.info("Processing zip file: {}".format(zip_path))
- with zipfile.ZipFile(zip_path, "r") as zip_file:
- zip_file.extractall(tmp_log_path)
- gl_logs = zip_file.namelist()
- # b/214145973 check if hidden exists in pixel logger zip file
- tmp_file = [name for name in gl_logs if 'tmp' in name]
- if tmp_file:
- ad.log.warn(f"Hidden file {tmp_file} exists in pixel logger zip file")
- break
- elif os.path.isdir(zip_path):
- ad.log.info("BRCM logs didn't zip properly. Log path is directory.")
- tmp_log_path = zip_path
- gl_logs = os.listdir(tmp_log_path)
- ad.log.info("Processing BRCM log files: {}".format(gl_logs))
- break
- else:
- raise signals.TestError(
- "No BRCM logs found in {}".format(os.listdir(tmp_log_path)))
- gl_logs = [log for log in gl_logs
- if log.startswith("gl") and log.endswith(".log")]
- for file in gl_logs:
- nmea_log_path = posixpath.join(tmp_log_path, file)
- ad.log.info("Parsing log pattern of \"%s\" in %s" % (nmea_pattern,
- nmea_log_path))
- brcm_log = open(nmea_log_path, "r", encoding="UTF-8", errors="ignore")
- lines = brcm_log.readlines()
- for line in lines:
- if nmea_pattern in line:
- brcm_log_list.append(line)
- for attr in brcm_log_error_pattern:
- if attr in line:
- benign_log = False
- for allow_log in brcm_error_log_allowlist:
- if allow_log in line:
- benign_log = True
- ad.log.info("\"%s\" is in allow-list and removed "
- "from error." % allow_log)
- if not benign_log:
- brcm_error_log_list.append(line)
+ if not isinstance(nmea_pattern, re.Pattern):
+ nmea_pattern = re.compile(nmea_pattern)
+
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ try:
+ ad.pull_files(pixellogger_path, tmp_dir)
+ except AdbCommandError:
+ raise FileNotFoundError("No pixel logger folders found")
+
+ # Although we don't rely on the zip file, stop pixel logger here to avoid
+ # wasting resources.
+ if stop_logger:
+ stop_pixel_logger(ad)
+
+ tmp_path = pathlib.Path(tmp_dir)
+ log_folders = sorted([x for x in tmp_path.iterdir() if x.is_dir()])
+ if not log_folders:
+ raise FileNotFoundError("No BRCM logs found.")
+ # The folder name is a string of datetime, the latest one will be in the last index.
+ gl_logs = log_folders[-1].glob("**/gl*.log")
+
+ for nmea_log_path in gl_logs:
+ ad.log.info("Parsing log pattern of \"%s\" in %s" % (nmea_pattern,
+ nmea_log_path))
+ with open(nmea_log_path, "r", encoding="UTF-8", errors="ignore") as lines:
+ for line in lines:
+ line = line.strip()
+ if nmea_pattern.fullmatch(line):
+ brcm_log_list.append(line)
+ for attr in brcm_log_error_pattern:
+ if attr in line:
+ benign_log = False
+ for regex_pattern in brcm_error_log_allowlist:
+ if re.search(regex_pattern, line):
+ benign_log = True
+ ad.log.debug("\"%s\" is in allow-list and removed "
+ "from error." % line)
+ if not benign_log:
+ brcm_error_log_list.append(line)
+
brcm_error_log = "".join(brcm_error_log_list)
- shutil.rmtree(tmp_log_path, ignore_errors=True)
return brcm_log_list, brcm_error_log
+def _get_power_mode_log_from_pixel_logger(ad, brcm_error_log_allowlist, stop_pixel_logger=True):
+ """Gets the power log from pixel logger.
+
+ Args:
+ ad: The device under test.
+ brcm_error_log_allow_list: The allow list to ignore certain error in pixel logger.
+ stop_pixel_logger: To disable pixel logger when getting the log.
+ """
+ pglor_list, brcm_error_log = parse_brcm_nmea_log(
+ ad, _BRCM_DUTY_CYCLE_PATTERN, brcm_error_log_allowlist, stop_pixel_logger)
+ if not pglor_list:
+ raise signals.TestFailure("Fail to get DPO logs from pixel logger")
+
+ return pglor_list, brcm_error_log
+
+
def check_dpo_rate_via_brcm_log(ad, dpo_threshold, brcm_error_log_allowlist):
"""Check DPO engage rate through "$PGLOR,11,STA" in BRCM Log.
D - Disabled, Always full power.
@@ -2164,10 +2464,7 @@
always_full_power_count = 0
full_power_count = 0
power_save_count = 0
- pglor_list, brcm_error_log = parse_brcm_nmea_log(
- ad, "$PGLOR,11,STA", brcm_error_log_allowlist)
- if not pglor_list:
- raise signals.TestFailure("Fail to get DPO logs from pixel logger")
+ pglor_list, brcm_error_log = _get_power_mode_log_from_pixel_logger(ad, brcm_error_log_allowlist)
for pglor in pglor_list:
power_res = re.compile(r',P,(\w),').search(pglor).group(1)
@@ -2199,74 +2496,77 @@
brcm_error_log))
-def pair_to_wearable(ad, ad1):
- """Pair phone to watch via Bluetooth.
+def process_pair(watch, phone):
+ """Pair phone to watch via Bluetooth in OOBE.
Args:
- ad: A pixel phone.
- ad1: A wearable project.
+ watch: A wearable project.
+ phone: A pixel phone.
"""
- check_location_service(ad1)
- utils.sync_device_time(ad1)
- bt_model_name = ad.adb.getprop("ro.product.model")
- bt_sn_name = ad.adb.getprop("ro.serialno")
+ check_location_service(phone)
+ utils.sync_device_time(phone)
+ bt_model_name = watch.adb.getprop("ro.product.model")
+ bt_sn_name = watch.adb.getprop("ro.serialno")
bluetooth_name = bt_model_name +" " + bt_sn_name[10:]
- fastboot_factory_reset(ad, False)
- ad.log.info("Wait 1 min for wearable system busy time.")
+ fastboot_factory_reset(watch, False)
+ # TODO (chenstanley)Need to re-structure for better code and test flow instead of simply waiting
+ watch.log.info("Wait 1 min for wearable system busy time.")
time.sleep(60)
- ad.adb.shell("input keyevent 4")
+ watch.adb.shell("input keyevent 4")
# Clear Denali paired data in phone.
- ad1.adb.shell("pm clear com.google.android.gms")
- ad1.adb.shell("pm clear com.google.android.apps.wear.companion")
- ad1.adb.shell("am start -S -n com.google.android.apps.wear.companion/"
+ phone.adb.shell("pm clear com.google.android.gms")
+ phone.adb.shell("pm clear com.google.android.apps.wear.companion")
+ phone.adb.shell("am start -S -n com.google.android.apps.wear.companion/"
"com.google.android.apps.wear.companion.application.RootActivity")
- uia_click(ad1, "Next")
- uia_click(ad1, "I agree")
- uia_click(ad1, bluetooth_name)
- uia_click(ad1, "Pair")
- uia_click(ad1, "Skip")
- uia_click(ad1, "Skip")
- uia_click(ad1, "Finish")
- ad.log.info("Wait 3 mins for complete pairing process.")
+ uia_click(phone, "Continue")
+ uia_click(phone, "More")
+ uia_click(phone, "I agree")
+ uia_click(phone, "I accept")
+ uia_click(phone, bluetooth_name)
+ uia_click(phone, "Pair")
+ uia_click(phone, "Skip")
+ uia_click(phone, "Next")
+ uia_click(phone, "Skip")
+ uia_click(phone, "Done")
+ # TODO (chenstanley)Need to re-structure for better code and test flow instead of simply waiting
+ watch.log.info("Wait 3 mins for complete pairing process.")
time.sleep(180)
- ad.adb.shell("settings put global stay_on_while_plugged_in 7")
- check_location_service(ad)
- enable_gnss_verbose_logging(ad)
- if is_bluetooth_connected(ad, ad1):
- ad.log.info("Pairing successfully.")
- else:
- raise signals.TestFailure("Fail to pair watch and phone successfully.")
+ set_screen_always_on(watch)
+ check_location_service(watch)
+ enable_gnss_verbose_logging(watch)
-def is_bluetooth_connected(ad, ad1):
+def is_bluetooth_connected(watch, phone):
"""Check if device's Bluetooth status is connected or not.
Args:
- ad: A wearable project
- ad1: A pixel phone.
+ watch: A wearable project
+ phone: A pixel phone.
"""
- return ad.droid.bluetoothIsDeviceConnected(ad1.droid.bluetoothGetLocalAddress())
+ return watch.droid.bluetoothIsDeviceConnected(phone.droid.bluetoothGetLocalAddress())
-def detect_crash_during_tracking(ad, begin_time, type):
+def detect_crash_during_tracking(ad, begin_time, api_type, ignore_hal_crash=False):
"""Check if GNSS or GPSTool crash happened druing GNSS Tracking.
Args:
ad: An AndroidDevice object.
begin_time: Start Time to check if crash happened in logs.
- type: Using GNSS or FLP reading method in GNSS tracking.
+ api_type: Using GNSS or FLP reading method in GNSS tracking.
+ ignore_hal_crash: In BRCM devices, once the HAL is being killed, it will write error/fatal logs.
+ Ignore this error if the error logs are expected.
"""
gnss_crash_list = [".*Fatal signal.*gnss",
- ".*Fatal signal.*xtra",
- ".*F DEBUG.*gnss",
- ".*Fatal signal.*gpsd"]
+ ".*Fatal signal.*xtra"]
+ if not ignore_hal_crash:
+ gnss_crash_list += [".*Fatal signal.*gpsd", ".*F DEBUG.*gnss"]
if not ad.is_adb_logcat_on:
ad.start_adb_logcat()
for attr in gnss_crash_list:
gnss_crash_result = ad.adb.shell(
- "logcat -d | grep -E -i '%s'" % attr)
+ "logcat -d | grep -E -i '%s'" % attr, ignore_status=True, timeout = 300)
if gnss_crash_result:
- start_gnss_by_gtw_gpstool(ad, state=False, type=type)
+ start_gnss_by_gtw_gpstool(ad, state=False, api_type=api_type)
raise signals.TestFailure(
"Test failed due to GNSS HAL crashed. \n%s" %
gnss_crash_result)
@@ -2381,57 +2681,103 @@
ad.log.info("Delete BCM's NVMEM ephemeris files.\n%s" % status)
-def bcm_gps_xml_add_option(ad,
+def bcm_gps_xml_update_option(ad,
+ option,
search_line=None,
append_txt=None,
+ update_txt=None,
+ delete_txt=None,
gps_xml_path=BCM_GPS_XML_PATH):
"""Append parameter setting in gps.xml for BCM solution
Args:
+ option: A str to identify the operation (add/update/delete).
ad: An AndroidDevice object.
search_line: Pattern matching of target
line for appending new line data.
- append_txt: New line that will be appended after the search_line.
+ append_txt: New lines that will be appended after the search_line.
+ update_txt: New line to update the original file.
+ delete_txt: lines to delete from the original file.
gps_xml_path: gps.xml file location of DUT
"""
remount_device(ad)
#Update gps.xml
- if not search_line or not append_txt:
- ad.log.info("Nothing for update.")
- else:
- tmp_log_path = tempfile.mkdtemp()
- ad.pull_files(gps_xml_path, tmp_log_path)
- gps_xml_tmp_path = os.path.join(tmp_log_path, "gps.xml")
- gps_xml_file = open(gps_xml_tmp_path, "r")
- lines = gps_xml_file.readlines()
- gps_xml_file.close()
- fout = open(gps_xml_tmp_path, "w")
- append_txt_tag = append_txt.strip()
+ tmp_log_path = tempfile.mkdtemp()
+ ad.pull_files(gps_xml_path, tmp_log_path)
+ gps_xml_tmp_path = os.path.join(tmp_log_path, "gps.xml")
+ gps_xml_file = open(gps_xml_tmp_path, "r")
+ lines = gps_xml_file.readlines()
+ gps_xml_file.close()
+ fout = open(gps_xml_tmp_path, "w")
+ if option == "add":
for line in lines:
- if append_txt_tag in line:
- ad.log.info('{} is already in the file. Skip'.format(append_txt))
+ if line.strip() in append_txt:
+ ad.log.info("{} is already in the file. Skip".format(append_txt))
continue
fout.write(line)
if search_line in line:
- fout.write(append_txt)
- ad.log.info("Update new line: '{}' in gps.xml.".format(append_txt))
- fout.close()
+ for add_txt in append_txt:
+ fout.write(add_txt)
+ ad.log.info("Add new line: '{}' in gps.xml.".format(add_txt))
+ elif option == "update":
+ for line in lines:
+ if search_line in line:
+ ad.log.info(line)
+ fout.write(update_txt)
+ ad.log.info("Update line: '{}' in gps.xml.".format(update_txt))
+ continue
+ fout.write(line)
+ elif option == "delete":
+ for line in lines:
+ if delete_txt in line:
+ ad.log.info("Delete line: '{}' in gps.xml.".format(line.strip()))
+ continue
+ fout.write(line)
+ fout.close()
- # Update gps.xml with gps_new.xml
- ad.push_system_file(gps_xml_tmp_path, gps_xml_path)
+ # Update gps.xml with gps_new.xml
+ ad.push_system_file(gps_xml_tmp_path, gps_xml_path)
- # remove temp folder
- shutil.rmtree(tmp_log_path, ignore_errors=True)
+ # remove temp folder
+ shutil.rmtree(tmp_log_path, ignore_errors=True)
+def bcm_gps_ignore_warmstandby(ad):
+ """ remove warmstandby setting in BCM gps.xml to reset tracking filter
+ Args:
+ ad: An AndroidDevice object.
+ """
+ search_line_tag = '<gll\n'
+ delete_line_str = 'WarmStandbyTimeout1Seconds'
+ bcm_gps_xml_update_option(ad,
+ "delete",
+ search_line_tag,
+ append_txt=None,
+ update_txt=None,
+ delete_txt=delete_line_str)
+
+ search_line_tag = '<gll\n'
+ delete_line_str = 'WarmStandbyTimeout2Seconds'
+ bcm_gps_xml_update_option(ad,
+ "delete",
+ search_line_tag,
+ append_txt=None,
+ update_txt=None,
+ delete_txt=delete_line_str)
def bcm_gps_ignore_rom_alm(ad):
""" Update BCM gps.xml with ignoreRomAlm="True"
Args:
ad: An AndroidDevice object.
"""
+ search_line_tag = '<hal\n'
+ append_line_str = [' IgnoreJniTime=\"true\"\n']
+ bcm_gps_xml_update_option(ad, "add", search_line_tag, append_line_str)
+
search_line_tag = '<gll\n'
- append_line_str = ' IgnoreRomAlm=\"true\"\n'
- bcm_gps_xml_add_option(ad, search_line_tag, append_line_str)
+ append_line_str = [' IgnoreRomAlm=\"true\"\n',
+ ' AutoColdStartSignal=\"SIMULATED\"\n',
+ ' IgnoreJniTime=\"true\"\n']
+ bcm_gps_xml_update_option(ad, "add", search_line_tag, append_line_str)
def check_inject_time(ad):
@@ -2449,35 +2795,477 @@
return True
raise signals.TestFailure("Fail to get time injected within %s attempts." % i)
+def recover_paired_status(watch, phone):
+ """Recover Bluetooth paired status if not paired.
-def enable_framework_log(ad):
- """Enable framework log for wearable to check UTC time download.
+ Args:
+ watch: A wearable project.
+ phone: A pixel phone.
+ """
+ for _ in range(3):
+ watch.log.info("Switch Bluetooth Off-On to recover paired status.")
+ for status in (False, True):
+ watch.droid.bluetoothToggleState(status)
+ phone.droid.bluetoothToggleState(status)
+ # TODO (chenstanley)Need to re-structure for better code and test flow instead of simply waiting
+ watch.log.info("Wait for Bluetooth auto re-connect.")
+ time.sleep(10)
+ if is_bluetooth_connected(watch, phone):
+ watch.log.info("Success to recover paired status.")
+ return True
+ raise signals.TestFailure("Fail to recover BT paired status in 3 attempts.")
+
+def push_lhd_overlay(ad):
+ """Push lhd_overlay.conf to device in /data/vendor/gps/overlay/
+
+ ad:
+ ad: An AndroidDevice object.
+ """
+ overlay_name = "lhd_overlay.conf"
+ overlay_asset = ad.adb.shell("ls /data/vendor/gps/overlay/")
+ if overlay_name in overlay_asset:
+ ad.log.info(f"{overlay_name} already in device, skip.")
+ return
+
+ temp_path = tempfile.mkdtemp()
+ file_path = os.path.join(temp_path, overlay_name)
+ lhd_content = 'Lhe477xDebugFlags=RPC:FACILITY=2097151:LOG_INFO:STDOUT_PUTS:STDOUT_LOG\n'\
+ 'LogLevel=*:E\nLogLevel=*:W\nLogLevel=*:I\nLog=LOGCAT\nLogEnabled=true\n'
+ overlay_path = "/data/vendor/gps/overlay/"
+ with open(file_path, "w") as f:
+ f.write(lhd_content)
+ ad.log.info("Push lhd_overlay to device")
+ ad.adb.push(file_path, overlay_path)
+
+
+def disable_ramdump(ad):
+ """Disable ramdump so device will reboot when about to enter ramdump
+
+ Once device enter ramdump, it will take a while to generate dump file
+ The process may take a while and block all the tests.
+ By disabling the ramdump mode, device will reboot instead of entering ramdump mode
Args:
ad: An AndroidDevice object.
"""
- remount_device(ad)
- time.sleep(3)
- ad.log.info("Start to enable framwork log for wearable.")
- ad.adb.shell("echo 'log.tag.LocationManagerService=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssLocationProvider=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GpsNetInitiatedHandler=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssNetInitiatedHandler=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssNetworkConnectivityHandler=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.NtpTimeHelper=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.ConnectivityService=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssPsdsDownloader=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssVisibilityControl=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.Gnss=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GnssConfiguration=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.ImsPhone=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GsmCdmaPhone=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.Phone=VERBOSE' >> /data/local.prop")
- ad.adb.shell("echo 'log.tag.GCoreFlp=VERBOSE' >> /data/local.prop")
- ad.adb.shell("chmod 644 /data/local.prop")
- ad.adb.shell("echo 'LogEnabled=true' > /data/vendor/gps/libgps.conf")
- ad.adb.shell("chown gps.system /data/vendor/gps/libgps.conf")
- ad.adb.shell("sync")
- reboot(ad)
- ad.log.info("Wait 2 mins for Wearable booting system busy")
- time.sleep(120)
+ ad.log.info("Enter bootloader mode")
+ ad.stop_services()
+ ad.adb.reboot("bootloader")
+ for _ in range(1,9):
+ if ad.is_bootloader:
+ break
+ time.sleep(1)
+ else:
+ raise signals.TestFailure("can't enter bootloader mode")
+ ad.log.info("Disable ramdump")
+ ad.fastboot.oem("ramdump disable")
+ ad.fastboot.reboot()
+ ad.wait_for_boot_completion()
+ ad.root_adb()
+ tutils.bring_up_sl4a(ad)
+ ad.start_adb_logcat()
+
+
+def deep_suspend_device(ad):
+ """Force DUT to enter deep suspend mode
+
+ When DUT is connected to PCs, it won't enter deep suspend mode
+ by pressing power button.
+
+ To force DUT enter deep suspend mode, we need to send the
+ following command to DUT "echo mem >/sys/power/state"
+
+ To make sure the DUT stays in deep suspend mode for a while,
+ it will send the suspend command 3 times with 15s interval
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ ad.log.info("Ready to go to deep suspend mode")
+ begin_time = get_device_time(ad)
+ ad.droid.goToSleepNow()
+ ensure_power_manager_is_dozing(ad, begin_time)
+ ad.stop_services()
+ try:
+ command = "echo deep > /sys/power/mem_sleep && echo mem > /sys/power/state"
+ for i in range(1, 4):
+ ad.log.debug(f"Send deep suspend command round {i}")
+ ad.adb.shell(command, ignore_status=True)
+ # sleep here to ensure the device stays enough time in deep suspend mode
+ time.sleep(15)
+ if not _is_device_enter_deep_suspend(ad):
+ raise signals.TestFailure("Device didn't enter deep suspend mode")
+ ad.log.info("Wake device up now")
+ except Exception:
+ # when exception happen, it's very likely the device is rebooting
+ # to ensure the test can go on, wait for the device is ready
+ ad.log.warn("Device may be rebooting, wait for it")
+ ad.wait_for_boot_completion()
+ ad.root_adb()
+ raise
+ finally:
+ tutils.bring_up_sl4a(ad)
+ ad.start_adb_logcat()
+ ad.droid.wakeUpNow()
+
+
+def get_device_time(ad):
+ """Get current datetime from device
+
+ Args:
+ ad: An AndroidDevice object.
+
+ Returns:
+ datetime object
+ """
+ result = ad.adb.shell("date +\"%Y-%m-%d %T.%3N\"")
+ return datetime.strptime(result, "%Y-%m-%d %H:%M:%S.%f")
+
+
+def ensure_power_manager_is_dozing(ad, begin_time):
+ """Check if power manager is in dozing
+ When device is sleeping, power manager should goes to doze mode.
+ To ensure that, we check the log every 1 second (maximum to 3 times)
+
+ Args:
+ ad: An AndroidDevice object.
+ begin_time: datetime, used as the starting point to search log
+ """
+ keyword = "PowerManagerService: Dozing"
+ ad.log.debug("Log search start time: %s" % begin_time)
+ for i in range(0,3):
+ result = ad.search_logcat(keyword, begin_time)
+ if result:
+ break
+ ad.log.debug("Power manager is not dozing... retry in 1 second")
+ time.sleep(1)
+ else:
+ ad.log.warn("Power manager didn't enter dozing")
+
+
+
+def _is_device_enter_deep_suspend(ad):
+ """Check device has been enter deep suspend mode
+
+ If device has entered deep suspend mode, we should be able to find keyword
+ "suspend entry (deep)"
+
+ Args:
+ ad: An AndroidDevice object.
+
+ Returns:
+ bool: True / False -> has / has not entered deep suspend
+ """
+ cmd = f"adb -s {ad.serial} logcat -d|grep \"suspend entry (deep)\""
+ process = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE, shell=True)
+ result, _ = process.communicate()
+ ad.log.debug(f"suspend result = {result}")
+
+ return bool(result)
+
+
+def check_location_report_interval(ad, location_reported_time_src, total_seconds, tolerance):
+ """Validate the interval between two location reported time
+ Normally the interval should be around 1 second but occasionally it may up to nearly 2 seconds
+ So we set up a tolerance - 99% of reported interval should be less than 1.3 seconds
+
+ We validate the interval backward, because the wrong interval mostly happened at the end
+ Args:
+ ad: An AndroidDevice object.
+ location_reported_time_src: A list of reported time(in string) from GPS tool
+ total_seconds: (int) how many seconds has the GPS been enabled
+ tolerance: (float) set how many ratio of error should be accepted
+ if we want to set tolerance to be 1% then pass 0.01 as tolerance value
+ """
+ ad.log.info("Checking location report frequency")
+ error_count = 0
+ error_tolerance = max(1, int(total_seconds * tolerance))
+ expected_longest_interval = 1.3
+ location_reported_time = list(map(lambda x: datetime.strptime(x, "%Y/%m/%d %H:%M:%S.%f"),
+ location_reported_time_src))
+ location_reported_time = sorted(location_reported_time)
+ last_gps_report_time = location_reported_time[-1]
+ ad.log.debug("Location report time: %s" % location_reported_time)
+
+ for reported_time in reversed(location_reported_time):
+ time_diff = last_gps_report_time - reported_time
+ if time_diff.total_seconds() > expected_longest_interval:
+ error_count += 1
+ last_gps_report_time = reported_time
+
+ if error_count > error_tolerance:
+ fail_message = (f"Interval longer than {expected_longest_interval}s "
+ f"exceed tolerance count: {error_tolerance}, error count: {error_count}")
+ ad.log.error(fail_message)
+
+
+@contextmanager
+def set_screen_status(ad, off=True):
+ """Set screen on / off
+
+ A context manager function, can be used with "with" statement.
+ example:
+ with set_screen_status(ad, off=True):
+ do anything you want during screen is off
+ Once the function end, it will turn on the screen
+ Args:
+ ad: AndroidDevice object
+ off: (bool) True -> turn off screen / False -> leave screen as it is
+ """
+ try:
+ if off:
+ ad.droid.goToSleepNow()
+ yield ad
+ finally:
+ ad.droid.wakeUpNow()
+ ensure_device_screen_is_on(ad)
+
+
+@contextmanager
+def full_gnss_measurement(ad):
+ """Context manager function to enable full gnss measurement"""
+ try:
+ ad.adb.shell("settings put global enable_gnss_raw_meas_full_tracking 1")
+ yield ad
+ finally:
+ ad.adb.shell("settings put global enable_gnss_raw_meas_full_tracking 0")
+
+
+def ensure_device_screen_is_on(ad):
+ """Make sure the screen is on
+
+ Will try 3 times, each with 1 second interval
+
+ Raise:
+ GnssTestUtilsError: if screen can't be turn on after 3 tries
+ """
+ for _ in range(3):
+ # when NotificationShade appears in focus window, it indicates the screen is still off
+ if "NotificationShade" not in check_current_focus_app(ad):
+ break
+ time.sleep(1)
+ else:
+ raise GnssTestUtilsError("Device screen is not on after 3 tries")
+
+
+def start_qxdm_and_tcpdump_log(ad, enable):
+ """Start QXDM and adb tcpdump if collect_logs is True.
+ Args:
+ ad: AndroidDevice object
+ enable: (bool) True -> start collecting
+ False -> not start collecting
+ """
+ if enable:
+ start_pixel_logger(ad)
+ tlutils.start_adb_tcpdump(ad)
+
+
+def set_screen_always_on(ad):
+ """Ensure the sceen will not turn off and display the correct app screen
+ for wearable, we also disable the charing screen,
+ otherwise the charing screen will keep popping up and block the GPS tool
+ """
+ if is_device_wearable(ad):
+ ad.adb.shell("settings put global stay_on_while_plugged_in 7")
+ ad.adb.shell("setprop persist.enable_charging_experience false")
+ else:
+ ad.adb.shell("settings put system screen_off_timeout 1800000")
+
+
+def validate_adr_rate(ad, pass_criteria):
+ """Check the ADR rate
+
+ Args:
+ ad: AndroidDevice object
+ pass_criteria: (float) the passing ratio, 1 = 100%, 0.5 = 50%
+ """
+ adr_statistic = GnssMeasurement(ad).get_adr_static()
+
+ ad.log.info("ADR threshold: {0:.1%}".format(pass_criteria))
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX + "ADR_valid_rate {0:.1%}".format(adr_statistic.valid_rate))
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX +
+ "ADR_usable_rate {0:.1%}".format(adr_statistic.usable_rate))
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX + "ADR_total_count %s" % adr_statistic.total_count)
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX + "ADR_valid_count %s" % adr_statistic.valid_count)
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX + "ADR_reset_count %s" % adr_statistic.reset_count)
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX +
+ "ADR_cycle_slip_count %s" % adr_statistic.cycle_slip_count)
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX +
+ "ADR_half_cycle_reported_count %s" % adr_statistic.half_cycle_reported_count)
+ ad.log.info(UPLOAD_TO_SPONGE_PREFIX +
+ "ADR_half_cycle_resolved_count %s" % adr_statistic.half_cycle_resolved_count)
+
+ asserts.assert_true(
+ (pass_criteria < adr_statistic.valid_rate) and (pass_criteria < adr_statistic.usable_rate),
+ f"ADR valid rate: {adr_statistic.valid_rate:.1%}, "
+ f"ADR usable rate: {adr_statistic.usable_rate:.1%} "
+ f"Lower than expected: {pass_criteria:.1%}"
+ )
+
+
+def pair_to_wearable(watch, phone):
+ """Pair watch to phone.
+
+ Args:
+ watch: A wearable project.
+ phone: A pixel phone.
+ Raise:
+ TestFailure: If pairing process could not success after 3 tries.
+ """
+ for _ in range(3):
+ process_pair(watch, phone)
+ if is_bluetooth_connected(watch, phone):
+ watch.log.info("Pairing successfully.")
+ return True
+ raise signals.TestFailure("Pairing is not successfully.")
+
+
+def disable_battery_defend(ad):
+ """Disable battery defend config to prevent battery defend message pop up
+ after connecting to the same charger for 4 days in a row.
+
+ Args:
+ ad: A wearable project.
+ """
+ for _ in range(5):
+ remount_device(ad)
+ ad.adb.shell("setprop vendor.battery.defender.disable 1")
+ # To simulate cable unplug and the status will be recover after device reboot.
+ ad.adb.shell("cmd battery unplug")
+ # Sleep 3 seconds for waiting adb commend changes config and simulates cable unplug.
+ time.sleep(3)
+ config_setting = ad.adb.shell("getprop vendor.battery.defender.state")
+ if config_setting == "DISABLED":
+ ad.log.info("Disable Battery Defend setting successfully.")
+ break
+
+
+def restart_hal_service(ad):
+ """Restart HAL service by killing the pid.
+
+ Gets the pid by ps command and pass the pid to kill command. Then we get the pid of HAL service
+ again to see if the pid changes(pid should be different after HAL restart). If not, we will
+ retry up to 4 times before raising Test Failure.
+
+ Args:
+ ad: AndroidDevice object
+ """
+ ad.log.info("Restart HAL service")
+ hal_process_name = "'android.hardware.gnss@[[:digit:]]\{1,2\}\.[[:digit:]]\{1,2\}-service'"
+ hal_pid = get_process_pid(ad, hal_process_name)
+ ad.log.info("HAL pid: %s" % hal_pid)
+
+ # Retry kill process if the PID is the same as original one
+ for _ in range(4):
+ ad.log.info("Kill HAL service")
+ ad.adb.shell(f"kill -9 {hal_pid}")
+
+ # Waits for the HAL service to restart up to 4 seconds.
+ for _ in range(4):
+ new_hal_pid = get_process_pid(ad, hal_process_name)
+ ad.log.info("New HAL pid: %s" % new_hal_pid)
+ if new_hal_pid:
+ if hal_pid != new_hal_pid:
+ return
+ break
+ time.sleep(1)
+ else:
+ raise signals.TestFailure("HAL service can't be killed")
+
+
+def run_ttff(ad, mode, criteria, test_cycle, base_lat_long, collect_logs=False):
+ """Verify TTFF functionality with mobile data.
+
+ Args:
+ mode: "cs", "ws" or "hs"
+ criteria: Criteria for the test.
+
+ Returns:
+ ttff_data: A dict of all TTFF data.
+ """
+ start_qxdm_and_tcpdump_log(ad, collect_logs)
+ return run_ttff_via_gtw_gpstool(ad, mode, criteria, test_cycle, base_lat_long)
+
+
+def re_register_measurement_callback(dut):
+ """Send command to unregister then register measurement callback.
+
+ Args:
+ dut: The device under test.
+ """
+ dut.log.info("Reregister measurement callback")
+ dut.adb.shell("am broadcast -a com.android.gpstool.stop_meas_action")
+ time.sleep(1)
+ dut.adb.shell("am broadcast -a com.android.gpstool.start_meas_action")
+ time.sleep(1)
+
+
+def check_power_save_mode_status(ad, full_power, begin_time, brcm_error_allowlist):
+ """Checks the power save mode status.
+
+ For Broadcom:
+ Gets NEMA sentences from pixel logger and retrieve the status [F, S, D].
+ F,S => not in full power mode
+ D => in full power mode
+ For Qualcomm:
+ Gets the HardwareClockDiscontinuityCount from logcat. In full power mode, the
+ HardwareClockDiscontinuityCount should not be increased.
+
+ Args:
+ ad: The device under test.
+ full_power: The device is in full power mode or not.
+ begin_time: It is used to get the correct logcat information for qualcomm.
+ brcm_error_allowlist: It is used to ignore certain error in pixel logger.
+ """
+ if check_chipset_vendor_by_qualcomm(ad):
+ _check_qualcomm_power_save_mode(ad, full_power, begin_time)
+ else:
+ _check_broadcom_power_save_mode(ad, full_power, brcm_error_allowlist)
+
+
+def _check_qualcomm_power_save_mode(ad, full_power, begin_time):
+ dpo_results = _get_dpo_info_from_logcat(ad, begin_time)
+ first_dpo_count = int(dpo_results[0]["log_message"].split()[-1])
+ final_dpo_count = int(dpo_results[-1]["log_message"].split()[-1])
+ dpo_count_diff = final_dpo_count - first_dpo_count
+ ad.log.debug("The DPO count diff is {diff}".format(diff=dpo_count_diff))
+ if full_power:
+ asserts.assert_equal(dpo_count_diff, 0, msg="DPO count diff should be 0")
+ else:
+ asserts.assert_true(dpo_count_diff > 0, msg="DPO count diff should be more than 0")
+
+
+def _check_broadcom_power_save_mode(ad, full_power, brcm_error_allowlist):
+ power_save_log, _ = _get_power_mode_log_from_pixel_logger(
+ ad, brcm_error_allowlist, stop_pixel_logger=False)
+ power_status = re.compile(r',P,(\w),').search(power_save_log[-2]).group(1)
+ ad.log.debug("The power status is {status}".format(status=power_status))
+ if full_power:
+ asserts.assert_true(power_status == "D", msg="Should be in full power mode")
+ else:
+ asserts.assert_true(power_status in ["F", "S"], msg="Should not be in full power mode")
+
+@contextmanager
+def run_gnss_tracking(ad, criteria, meas_flag):
+ """A context manager to enable gnss tracking and stops at the end.
+
+ Args:
+ ad: The device under test.
+ criteria: The criteria for First Fixed.
+ meas_flag: A flag to turn on measurement log or not.
+ """
+ process_gnss_by_gtw_gpstool(ad, criteria=criteria, meas_flag=meas_flag)
+ try:
+ yield
+ finally:
+ start_gnss_by_gtw_gpstool(ad, state=False)
+
+def log_current_epoch_time(ad, sponge_key):
+ """Logs current epoch timestamp in second.
+
+ Args:
+ sponge_key: The key name of the sponge property.
+ """
+ current_epoch_time = get_current_epoch_time() // 1000
+ ad.log.info(f"TestResult {sponge_key} {current_epoch_time}")
\ No newline at end of file
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnss_testlog_utils.py b/acts_tests/acts_contrib/test_utils/gnss/gnss_testlog_utils.py
index 4f5df3c..5e7cf26 100644
--- a/acts_tests/acts_contrib/test_utils/gnss/gnss_testlog_utils.py
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnss_testlog_utils.py
@@ -209,17 +209,17 @@
configs=CONFIG_GPSTTFFLOG,
)
ttff_df = parsed_data['ttff_info']
-
- # Data Conversion
- ttff_df['loop'] = ttff_df['loop'].astype(int)
- ttff_df['start_datetime'] = pds.to_datetime(ttff_df['start_datetime'])
- ttff_df['stop_datetime'] = pds.to_datetime(ttff_df['stop_datetime'])
- ttff_df['ttff_time'] = ttff_df['ttff'].astype(float)
- ttff_df['ant_avg_top4_cn0'] = ttff_df['ant_avg_top4_cn0'].astype(float)
- ttff_df['ant_avg_cn0'] = ttff_df['ant_avg_cn0'].astype(float)
- ttff_df['bb_avg_top4_cn0'] = ttff_df['bb_avg_top4_cn0'].astype(float)
- ttff_df['bb_avg_cn0'] = ttff_df['bb_avg_cn0'].astype(float)
- ttff_df['satnum_for_fix'] = ttff_df['satnum_for_fix'].astype(int)
+ if not ttff_df.empty:
+ # Data Conversion
+ ttff_df['loop'] = ttff_df['loop'].astype(int)
+ ttff_df['start_datetime'] = pds.to_datetime(ttff_df['start_datetime'])
+ ttff_df['stop_datetime'] = pds.to_datetime(ttff_df['stop_datetime'])
+ ttff_df['ttff_time'] = ttff_df['ttff'].astype(float)
+ ttff_df['ant_avg_top4_cn0'] = ttff_df['ant_avg_top4_cn0'].astype(float)
+ ttff_df['ant_avg_cn0'] = ttff_df['ant_avg_cn0'].astype(float)
+ ttff_df['bb_avg_top4_cn0'] = ttff_df['bb_avg_top4_cn0'].astype(float)
+ ttff_df['bb_avg_cn0'] = ttff_df['bb_avg_cn0'].astype(float)
+ ttff_df['satnum_for_fix'] = ttff_df['satnum_for_fix'].astype(int)
# return ttff dataframe
return ttff_df
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnssstatus_utils.py b/acts_tests/acts_contrib/test_utils/gnss/gnssstatus_utils.py
new file mode 100644
index 0000000..457ba86
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnssstatus_utils.py
@@ -0,0 +1,200 @@
+#!/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 re
+from acts import signals
+from collections import defaultdict
+
+SVID_RANGE = {
+ 'GPS': [(1, 32)],
+ 'SBA': [(120, 192)],
+ 'GLO': [(1, 24), (93, 106)],
+ 'QZS': [(193, 200)],
+ 'BDS': [(1, 63)],
+ 'GAL': [(1, 36)],
+ 'NIC': [(1, 14)]
+}
+
+CARRIER_FREQUENCIES = {
+ 'GPS': {
+ 'L1': [1575.42],
+ 'L5': [1176.45]
+ },
+ 'SBA': {
+ 'L1': [1575.42]
+ },
+ 'GLO': {
+ 'L1': [round((1602 + i * 0.5625), 3) for i in range(-7, 7)]
+ },
+ 'QZS': {
+ 'L1': [1575.42],
+ 'L5': [1176.45]
+ },
+ 'BDS': {
+ 'B1': [1561.098],
+ 'B2a': [1176.45]
+ },
+ 'GAL': {
+ 'E1': [1575.42],
+ 'E5a': [1176.45]
+ },
+ 'NIC': {
+ 'L5': [1176.45]
+ }
+}
+
+
+class RegexParseException(Exception):
+ pass
+
+
+class GnssSvidContainer:
+ """A class to hold the satellite svid information
+
+ Attributes:
+ used_in_fix: A dict contains unique svid used in fixing location
+ not_used_in_fix: A dict contains unique svid not used in fixing location
+ """
+
+ def __init__(self):
+ self.used_in_fix = defaultdict(set)
+ self.not_used_in_fix = defaultdict(set)
+
+ def add_satellite(self, gnss_status):
+ """Add satellite svid into container
+
+ According to the attributes gnss_status.used_in_fix
+ True: add svid into self.used_in_fix container
+ False: add svid into self.not_used_in_fix container
+
+ Args:
+ gnss_status: A GnssStatus object
+ """
+ key = f'{gnss_status.constellation}_{gnss_status.frequency_band}'
+ if gnss_status.used_in_fix:
+ self.used_in_fix[key].add(gnss_status.svid)
+ else:
+ self.not_used_in_fix[key].add(gnss_status.svid)
+
+
+class GnssStatus:
+ """GnssStatus object, it will create an obj with a raw gnssstatus line.
+
+ Attributes:
+ raw_message: (string) The raw log from GSPTool
+ example:
+ Fix: true Type: NIC SV: 4 C/No: 45.10782, 40.9 Elevation: 78.0
+ Azimuth: 291.0
+ Signal: L5 Frequency: 1176.45 EPH: true ALM: false
+ Fix: false Type: GPS SV: 27 C/No: 34.728134, 30.5 Elevation:
+ 76.0 Azimuth: 15.0
+ Signal: L1 Frequency: 1575.42 EPH: true ALM: true
+ used_in_fix: (boolean) Whether or not this satellite info is used to fix
+ location
+ constellation: (string) The constellation type i.e. GPS
+ svid: (int) The unique id of the constellation
+ cn: (float) The C/No value from antenna
+ base_cn: (float) The C/No value from baseband
+ elev: (float) The value of elevation
+ azim: (float) The value of azimuth
+ frequency_band: (string) The frequency_type of the constellation i.e. L1
+ / L5
+ """
+
+ gnssstatus_re = (
+ r'Fix: (.*) Type: (.*) SV: (.*) C/No: (.*), (.*) '
+ r'Elevation: (.*) Azimuth: (.*) Signal: (.*) Frequency: (.*) EPH')
+ failures = []
+
+ def __init__(self, gnssstatus_raw):
+ status_res = re.search(self.gnssstatus_re, gnssstatus_raw)
+ if not status_res:
+ raise RegexParseException(f'Gnss raw msg parse fail:\n{gnssstatus_raw}\n'
+ f'Please check it manually.')
+ self.raw_message = gnssstatus_raw
+ self.used_in_fix = status_res.group(1).lower() == 'true'
+ self.constellation = status_res.group(2)
+ self.svid = int(status_res.group(3))
+ self.cn = float(status_res.group(4))
+ self.base_cn = float(status_res.group(5))
+ self.elev = float(status_res.group(6))
+ self.azim = float(status_res.group(7))
+ self.frequency_band = status_res.group(8)
+ self.carrier_frequency = float(status_res.group(9))
+
+ def validate_gnssstatus(self):
+ """A validate function for each property."""
+ self._validate_sv()
+ self._validate_cn()
+ self._validate_elev()
+ self._validate_azim()
+ self._validate_carrier_frequency()
+ if self.failures:
+ failure_info = '\n'.join(self.failures)
+ raise signals.TestFailure(
+ f'Gnsstatus validate failed:\n{self.raw_message}\n{failure_info}'
+ )
+
+ def _validate_sv(self):
+ """A validate function for SV ID."""
+ if not self.constellation in SVID_RANGE.keys():
+ raise signals.TestFailure(
+ f'Satellite identify fail: {self.constellation}')
+ for id_range in SVID_RANGE[self.constellation]:
+ if id_range[0] <= self.svid <= id_range[1]:
+ break
+ else:
+ fail_details = f'{self.constellation} ID {self.svid} not in SV Range'
+ self.failures.append(fail_details)
+
+ def _validate_cn(self):
+ """A validate function for CN value."""
+ if not 0 <= self.cn <= 63:
+ self.failures.append(f'Ant CN not in range: {self.cn}')
+ if not 0 <= self.base_cn <= 63:
+ self.failures.append(f'Base CN not in range: {self.base_cn}')
+
+ def _validate_elev(self):
+ """A validate function for Elevation (should between 0-90)."""
+ if not 0 <= self.elev <= 90:
+ self.failures.append(f'Elevation not in range: {self.elev}')
+
+ def _validate_azim(self):
+ """A validate function for Azimuth (should between 0-360)."""
+ if not 0 <= self.azim <= 360:
+ self.failures.append(f'Azimuth not in range: {self.azim}')
+
+ def _validate_carrier_frequency(self):
+ """A validate function for carrier frequency (should fall in below range).
+
+ 'GPS': L1:1575.42, L5:1176.45
+ 'SBA': L1:1575.42
+ 'GLO': L1:Between 1598.0625 and 1605.375
+ 'QZS': L1:1575.42, L5:1176.45
+ 'BDS': B1:1561.098, B2a:1176.45
+ 'GAL': E1:1575.42, E5a:1176.45
+ 'NIC': L5:1176.45
+ """
+ if self.frequency_band in CARRIER_FREQUENCIES[
+ self.constellation].keys():
+ target_freq = CARRIER_FREQUENCIES[self.constellation][
+ self.frequency_band]
+ else:
+ raise signals.TestFailure(
+ f'Carrier frequency identify fail: {self.frequency_band}')
+ if not self.carrier_frequency in target_freq:
+ self.failures.append(
+ f'{self.constellation}_{self.frequency_band} carrier'
+ f'frequency not in range: {self.carrier_frequency}')
diff --git a/acts_tests/acts_contrib/test_utils/gnss/supl.py b/acts_tests/acts_contrib/test_utils/gnss/supl.py
new file mode 100644
index 0000000..f6c1bc6
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/supl.py
@@ -0,0 +1,71 @@
+import os
+import tempfile
+from xml.etree import ElementTree
+
+
+def set_supl_over_wifi_state(ad, turn_on):
+ """Enable / Disable supl over wifi features
+
+ Modify the gps xml file: /vendor/etc/gnss/gps.xml
+ Args:
+ ad: AndroidDevice object
+ turn_on: (bool) True -> enable / False -> disable
+ """
+ ad.adb.remount()
+ folder = tempfile.mkdtemp()
+ xml_path_on_host = os.path.join(folder, "gps.xml")
+ xml_path_on_device = "/vendor/etc/gnss/gps.xml"
+ ad.pull_files(xml_path_on_device, xml_path_on_host)
+
+ # register namespance to aviod adding ns0 into xml attributes
+ ElementTree.register_namespace("", "http://www.glpals.com/")
+ xml_tree = ElementTree.parse(xml_path_on_host)
+ root = xml_tree.getroot()
+ for node in root:
+ if "hal" in node.tag:
+ if turn_on:
+ _enable_supl_over_wifi(ad, node)
+ else:
+ _disable_supl_over_wifi(ad, node)
+ xml_tree.write(xml_path_on_host, xml_declaration=True, encoding="utf-8", method="xml")
+ ad.push_system_file(xml_path_on_host, xml_path_on_device)
+
+
+def _enable_supl_over_wifi(ad, node):
+ """Enable supl over wifi
+ Detail setting:
+ <hal
+ SuplDummyCellInfo="true"
+ SuplUseApn="false"
+ SuplUseApnNI="true"
+ SuplUseFwCellInfo="false"
+ />
+ Args:
+ ad: AndroidDevice object
+ node: ElementTree node
+ """
+ ad.log.info("Enable SUPL over wifi")
+ attributes = {"SuplDummyCellInfo": "true", "SuplUseApn": "false", "SuplUseApnNI": "true",
+ "SuplUseFwCellInfo": "false"}
+ for key, value in attributes.items():
+ node.set(key, value)
+
+
+def _disable_supl_over_wifi(ad, node):
+ """Disable supl over wifi
+ Detail setting:
+ <hal
+ SuplUseApn="true"
+ />
+ Remove following setting
+ SuplDummyCellInfo="true"
+ SuplUseApnNI="true"
+ SuplUseFwCellInfo="false"
+ Args:
+ ad: AndroidDevice object
+ node: ElementTree node
+ """
+ ad.log.info("Disable SUPL over wifi")
+ for attri in ["SuplDummyCellInfo", "SuplUseApnNI", "SuplUseFwCellInfo"]:
+ node.attrib.pop(attri, None)
+ node.set("SuplUseApn", "true")
diff --git a/acts_tests/acts_contrib/test_utils/gnss/testtracker_util.py b/acts_tests/acts_contrib/test_utils/gnss/testtracker_util.py
new file mode 100644
index 0000000..43f7920
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/testtracker_util.py
@@ -0,0 +1,88 @@
+TEST_NAME_BY_TESTTRACKER_UUID = {
+ # GnssFunctionTest
+ "test_cs_first_fixed_system_server_restart": "8169c19d-ba2a-4fef-969b-87f793f4e699",
+ "test_cs_ttff_after_gps_service_restart": "247110d9-1c9e-429e-8e73-f16dd4a1ac74",
+ "test_gnss_one_hour_tracking": "b3d20ecb-3727-48ed-8a03-19694cc726c1",
+ "test_duty_cycle_function": "0bbfb818-da93-41d7-8d83-15bc53d8d2cf",
+ "test_gnss_init_error": "c661780d-4864-4292-9988-88f64448fb78",
+ "test_sap_valid_modes": "89bb8103-a3af-4953-8f07-e43c7e829bdd",
+ "test_network_location_provider_cell": "6f59d0f5-569c-4d52-990b-0042123b70ab",
+ "test_network_location_provider_wifi": "eec8b4bd-6990-4098-ad7a-acc19574bdee",
+ "test_gmap_location_report_battery_saver": "040556bf-1ffc-4db2-b2c5-19c4da19a256",
+ "test_gnss_ttff_cs_airplane_mode_on": "bc3d509c-0392-4af1-a0d0-68fd01167573",
+ "test_gnss_ttff_ws_airplane_mode_on": "dcafc69a-095e-4d58-8afb-5276c5763f4d",
+ "test_gnss_ttff_hs_airplane_mode_on": "090ea66c-19a1-4d0b-8c7e-dbc967597764",
+ "test_cs_ttff_in_weak_gnss_signal": "1980f980-3134-47b0-8dd8-9c5af6b742a6",
+ "test_ws_ttff_in_weak_gnss_signal": "d77c8db1-687b-48c5-8101-e4267da05995",
+ "test_hs_ttff_in_weak_gnss_signal": "dd4ccd93-9e49-45c2-a3ea-40781a40b820",
+ "test_quick_toggle_gnss_state": "36c14727-5de7-4589-ad1b-9119f9d9bb52",
+ "test_gnss_init_after_reboot": "79be8ab6-26cb-4d1a-b3d3-4e5681766901",
+ "test_host_gnssstatus_validation": "767c3024-0db4-4d40-9b03-f30355d72a06",
+ "test_onchip_gnssstatus_validation": "afb08722-2c79-46a6-80fd-9ede5018e384",
+ "test_location_update_after_resuming_from_deep_suspend": "140a7763-f42c-4917-a71f-fbc0626c1609",
+ "test_location_mode_in_battery_saver_with_screen_off": "04b529f1-a99d-4b18-9bba-41e008249f7a",
+ "test_measure_adr_rate_after_10_mins_tracking": "7ebf3b52-229a-4eaf-bbff-7c527e4a1d7c",
+ "test_hal_crashing_should_resume_tracking": "0aee4450-edce-4e1a-8744-70d8c01937b0",
+ "test_power_save_mode_should_apply_latest_measurement_setting": "59a14da2-40df-4106-a190-dcbcd2e877e0",
+ # GnssConcurrencyTest
+ "test_gnss_concurrency_location_1_chre_1": "cbd9ff54-4405-44a4-ac20-de33278406d1",
+ "test_gnss_concurrency_location_1_chre_8": "ab56cb47-384e-4269-b2d8-6e80ce066de2",
+ "test_gnss_concurrency_location_15_chre_8": "e64fa984-6219-43dd-96d6-d4141b2da1cd",
+ "test_gnss_concurrency_location_61_chre_1": "217f3ab6-25c9-4092-8fe1-f4e4199d60c6",
+ "test_gnss_concurrency_location_61_chre_10": "c32ca948-0414-4529-98d0-8351b5f31bab",
+ "test_gnss_chre_1": "9dae57f3-70f9-4328-a448-925da88725ac",
+ "test_gnss_chre_8": "a8c8f7fa-4dfd-42d8-ac6a-c3e3f186e317",
+ "test_variable_interval_via_chre": "53b161e5-335e-44a7-ae2e-eae7464a2b37",
+ "test_variable_interval_via_framework": "6b525afa-1427-4a99-906f-bc0aab6d4d30",
+ "test_gps_engine_switching_host_to_onchip": "07e0e138-4966-4307-b600-0521e626b967",
+ "test_gps_engine_switching_onchip_to_host": "564a229e-e784-43af-b430-4ab14656cfdc",
+ "test_mcu_cs_ttff": "736da33a-a976-44b6-93b3-bcfd847dd03d",
+ "test_mcu_ws_ttff": "e3457e35-9872-4677-8170-bc30d84798c0",
+ "test_mcu_hs_ttff": "0e1ce60d-e257-4dc5-b927-7ae97c8386b6",
+ # GnssBroadcomConfigurationTest
+ "test_gps_logenabled_setting": "d1310171-1641-4fa2-8802-cca7ce33bbd4",
+ "test_gps_supllogenable_setting": "ebe30341-4097-4e2c-b104-0c592f1f9e83",
+ "test_lhe_setting": "099aea19-5078-447c-925f-01a702624884",
+ # GnssSuplTest
+ "test_supl_capabilities": "6c794396-46e8-4674-8985-49a7b3059372",
+ "test_supl_ttff_cs": "ae8b6d54-bdd6-44a1-b1fa-4e90e0318080",
+ "test_supl_ttff_ws": "65f25e0b-c6d0-47c5-ab1f-0b02b621411d",
+ "test_supl_ttff_hs": "a2267586-97e9-465c-8d3a-22882c8671e7",
+ "test_cs_ttff_supl_over_wifi_with_airplane_mode_on": "4b2882f8-2966-4b44-9a31-37318beb84bf",
+ "test_ws_ttff_supl_over_wifi_with_airplane_mode_on": "a7f77afe-c82e-4b1b-ae54-e3fea17bf721",
+ "test_hs_ttff_supl_over_wifi_with_airplane_mode_on": "bc9de22f-90a0-4f2b-8052-cb4529f745e3",
+ "test_ttff_gla_on": "06aa85a2-7c3a-453a-b765-dc9ea6ee6b9b",
+ "test_ttff_gla_off": "36347b6e-d03e-4773-82bf-2e12d4f4dd0d",
+ # GnssVendorFeaturesTest
+ "test_xtra_ttff_cs_mobile_data": "da0bf0a1-d635-4942-808a-30070cfb2c78",
+ "test_xtra_ttff_ws_mobile_data": "95f17477-c88e-4663-a0ab-c09dc1706f75",
+ "test_xtra_ttff_hs_mobile_data": "bf13e2e4-79c9-4769-9dfd-81b085112744",
+ "test_xtra_ttff_cs_wifi": "5c0f95d2-7c76-45ca-95c8-304c742e0c82",
+ "test_xtra_ttff_ws_wifi": "507b2da1-c58d-4bca-810b-b274082a21c4",
+ "test_xtra_ttff_hs_wifi": "69d1998a-dd78-46a9-904d-d28f07dc3ef2",
+ "test_xtra_download_mobile_data": "d260a510-941a-48c7-a545-d7239f8f03dc",
+ "test_xtra_download_wifi": "e1dec4d2-4a85-4680-92df-57c972c084aa",
+ "test_lto_download_after_reboot": "579d249e-d533-4979-915f-b3a7d847546e",
+ "test_ws_with_assist": "938cbc1f-0374-473c-b4c1-1b4af734f16a",
+ "test_cs_with_assist": "9eae7b7d-9356-4fd8-bc18-f9d93aa0a92b",
+ # GnssWearableTetherFunctionTest
+ "test_flp_ttff_cs": "6dec9502-7e74-4590-b174-be822ceefcdb",
+ "test_flp_ttff_ws": "ddb8f09d-4757-42ae-9707-1fdb38187d1f",
+ "test_flp_ttff_hs": "19a997da-7c36-4fef-bf68-497d7c21163f",
+ "test_tracking_during_bt_disconnect_resume": "c9e26620-e518-4c7d-afcc-f81f6d3971bb",
+ "test_oobe_first_fix": "432e799c-3d02-46de-84d5-d5a22feceef8",
+ "test_oobe_first_fix_with_network_connection": "66264dac-50d0-4bc0-be72-6dbe9159587b",
+ "test_far_start_ttff": "4693b424-1a24-4002-b51d-df6b6bb91830",
+}
+
+def log_testtracker_uuid(ad, current_test_name):
+ """Logs testtracker uuid for the current test case.
+
+ Args:
+ ad: Target AndroidDevice object.
+ current_test_name: Current test name used to map testtracker uuid.
+ """
+ current_test_uuid = TEST_NAME_BY_TESTTRACKER_UUID.get(
+ current_test_name, None)
+ if current_test_uuid:
+ ad.log.info(f"TestResult mobly_uid {current_test_uuid}")
\ No newline at end of file
diff --git a/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py b/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
index 11094fb..7af1e12 100644
--- a/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
@@ -27,6 +27,7 @@
from acts import base_test
from acts import utils
from acts.metrics.loggers.blackbox import BlackboxMetricLogger
+from acts.controllers.adb_lib.error import AdbError
from acts_contrib.test_utils.power.loggers.power_metric_logger import PowerMetricLogger
from acts_contrib.test_utils.power import plot_utils
@@ -35,6 +36,8 @@
THRESHOLD_TOLERANCE_DEFAULT = 0.2
GET_FROM_PHONE = 'get_from_dut'
GET_FROM_AP = 'get_from_ap'
+GET_PROPERTY_HARDWARE_PLATFORM = 'getprop ro.boot.hardware.platform'
+POWER_STATS_DUMPSYS_CMD = 'dumpsys android.hardware.power.stats.IPowerStats/default delta'
PHONE_BATTERY_VOLTAGE_DEFAULT = 4.2
MONSOON_MAX_CURRENT = 8.0
DEFAULT_MONSOON_FREQUENCY = 500
@@ -76,6 +79,7 @@
self.dut = None
self.power_logger = PowerMetricLogger.for_test_case()
self.power_monitor = None
+ self.odpm_folder = None
@property
def final_test(self):
@@ -150,13 +154,23 @@
iperf_duration=None,
pass_fail_tolerance=THRESHOLD_TOLERANCE_DEFAULT,
mon_voltage=PHONE_BATTERY_VOLTAGE_DEFAULT,
- ap_dtim_period=None)
+ ap_dtim_period=None,
+ bits_root_rail_csv_export=False)
# Setup the must have controllers, phone and monsoon
self.dut = self.android_devices[0]
self.mon_data_path = os.path.join(self.log_path, 'Monsoon')
os.makedirs(self.mon_data_path, exist_ok=True)
+ # Make odpm path for P21 or later
+ platform = self.dut.adb.shell(GET_PROPERTY_HARDWARE_PLATFORM)
+ self.log.info('The hardware platform is {}'.format(platform))
+ if platform.startswith('gs'):
+ self.odpm_folder = os.path.join(self.log_path, 'odpm')
+ os.makedirs(self.odpm_folder, exist_ok=True)
+ self.log.info('For P21 or later, create odpm folder {}'.format(
+ self.odpm_folder))
+
# Initialize the power monitor object that will be used to measure
self.initialize_power_monitor()
@@ -279,6 +293,26 @@
def on_pass(self, test_name, begin_time):
self.power_logger.set_pass_fail_status('PASS')
+ def dut_save_odpm(self, tag):
+ """Dumpsys ODPM data and save it to self.odpm_folder.
+
+ Args:
+ tag: the moment of save ODPM data
+ """
+ odpm_file_name = '{}.{}.dumpsys_odpm_{}.txt'.format(
+ self.__class__.__name__,
+ self.current_test_name,
+ tag)
+ odpm_file_path = os.path.join(self.odpm_folder, odpm_file_name)
+
+ try:
+ stats = self.dut.adb.shell(POWER_STATS_DUMPSYS_CMD)
+ with open(odpm_file_path, 'w') as f:
+ f.write(stats)
+ except AdbError as e:
+ self.log.warning('Odpm data with tag {} did not save due to adb '
+ 'error {}'.format(e))
+
def dut_rockbottom(self):
"""Set the dut to rockbottom state
@@ -464,6 +498,11 @@
# Start the power measurement using monsoon.
self.dut.stop_services()
time.sleep(1)
+
+ # P21 or later device, save the odpm data before power measurement
+ if self.odpm_folder:
+ self.dut_save_odpm('before')
+
self.power_monitor.disconnect_usb()
measurement_args = dict(duration=self.mon_info.duration,
measure_after_seconds=self.mon_info.offset,
@@ -473,9 +512,15 @@
start_time=device_to_host_offset,
monsoon_output_path=data_path)
self.power_monitor.release_resources()
+ self.collect_raw_data_samples()
self.power_monitor.connect_usb()
self.dut.wait_for_boot_completion()
time.sleep(10)
+
+ # For P21 or later device, save the odpm data after power measurement
+ if self.odpm_folder:
+ self.dut_save_odpm('after')
+
self.dut.start_services()
return self.power_monitor.get_waveform(file_path=data_path)
@@ -510,3 +555,9 @@
self.log.warning('Cannot get iperf result. Setting to 0')
throughput = 0
return throughput
+
+ def collect_raw_data_samples(self):
+ if hasattr(self, 'bitses') and self.bits_root_rail_csv_export:
+ path = os.path.join(os.path.dirname(self.mon_info.data_path),
+ 'Kibble')
+ self.power_monitor.get_bits_root_rail_csv_export(path, self.test_name)
diff --git a/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py b/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
index baedb7e..201f17f 100644
--- a/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
@@ -41,6 +41,7 @@
self.set_xtra_data()
def setup_test(self):
+ gutils.log_current_epoch_time(self.ad, "test_start_time")
super().setup_test()
# Enable DPO
self.enable_DPO(True)
@@ -53,6 +54,7 @@
begin_time = utils.get_current_epoch_time()
self.ad.take_bug_report(self.test_name, begin_time)
gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path)
+ gutils.log_current_epoch_time(self.ad, "test_end_time")
def set_xtra_data(self):
gutils.disable_xtra_throttle(self.ad)
diff --git a/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_base_test.py b/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_base_test.py
index 7285a16..f2ebea9 100644
--- a/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_base_test.py
+++ b/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_base_test.py
@@ -19,6 +19,7 @@
import acts_contrib.test_utils.power.PowerBaseTest as PBT
import acts_contrib.test_utils.cellular.cellular_base_test as CBT
from acts_contrib.test_utils.power import plot_utils
+from acts import context
class PowerCellularLabBaseTest(CBT.CellularBaseTest, PBT.PowerBaseTest):
diff --git a/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_preset_base_test.py b/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_preset_base_test.py
new file mode 100644
index 0000000..15043d4
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/power/cellular/cellular_power_preset_base_test.py
@@ -0,0 +1,414 @@
+import os
+from typing import Optional, List
+import time
+from acts import context
+from acts import signals
+from acts.controllers.cellular_lib import AndroidCellularDut
+import acts_contrib.test_utils.power.cellular.cellular_power_base_test as PWCEL
+
+# TODO: b/261639867
+class AtUtil():
+ """Util class for sending at command.
+
+ Attributes:
+ dut: AndroidDevice controller object.
+ """
+ ADB_CMD_DISABLE_TXAS = 'am instrument -w -e request at+googtxas=2 -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+
+ def __init__(self, dut, log) -> None:
+ self.dut = dut
+ self.log = log
+
+ # TODO: to be remove when b/261639867 complete,
+ # and we are using parent method.
+ def send(self, cmd: str,) -> Optional[str]:
+ res = str(self.dut.adb.shell(cmd))
+ self.log.info(f'cmd sent: {cmd}')
+ self.log.info(f'response: {res}')
+ if 'SUCCESS' in res:
+ self.log.info('Command executed.')
+ else:
+ self.log.error('Fail to executed command.')
+ return res
+
+ def lock_LTE(self):
+ adb_enable_band_lock_lte = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Band.Select\ Enb\/\ Dis\",00,\"01\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_set_band_lock_mode_lte = r'am instrument -w -e request at+GOOGSETNV=\"NASU.SIPC.NetworkMode.ManualMode\",0,\"0D\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_set_band_lock_bitmap_0 = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Enabled.RFBands.BitMap\",0,\"09,00,00,00,00,00,00,00\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_set_band_lock_bitmap_1 = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Enabled.RFBands.BitMap\",1,\"00,00,00,00,00,00,00,00\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_set_band_lock_bitmap_2 = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Enabled.RFBands.BitMap\",2,\"00,00,00,00,00,00,00,00\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_set_band_lock_bitmap_3 = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Enabled.RFBands.BitMap\",3,\"00,00,00,00,00,00,00,00\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+
+ # enable lte
+ self.send(adb_enable_band_lock_lte)
+ time.sleep(2)
+
+ # OD is for NR/LTE in 4412 menu
+ self.send(adb_set_band_lock_mode_lte)
+ time.sleep(2)
+
+ # lock to B1 and B4
+ self.send(adb_set_band_lock_bitmap_0)
+ time.sleep(2)
+ self.send(adb_set_band_lock_bitmap_1)
+ time.sleep(2)
+ self.send(adb_set_band_lock_bitmap_2)
+ time.sleep(2)
+ self.send(adb_set_band_lock_bitmap_3)
+ time.sleep(2)
+
+ def clear_lock_band(self):
+ adb_set_band_lock_mode_auto = r'am instrument -w -e request at+GOOGSETNV=\"NASU.SIPC.NetworkMode.ManualMode\",0,\"03\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ adb_disable_band_lock_lte = r'am instrument -w -e request at+GOOGSETNV=\"!SAEL3.Manual.Band.Select\ Enb\/\ Dis\",0,\"00\" -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+
+ # band lock mode auto
+ self.send(adb_set_band_lock_mode_auto)
+ time.sleep(2)
+
+ # disable band lock lte
+ self.send(adb_disable_band_lock_lte)
+ time.sleep(2)
+
+ def disable_txas(self):
+ cmd = self.ADB_CMD_DISABLE_TXAS
+ response = self.send(cmd)
+ return 'OK' in response
+
+class PowerCellularPresetLabBaseTest(PWCEL.PowerCellularLabBaseTest):
+ # Key for ODPM report
+ ODPM_ENERGY_TABLE_NAME = 'PowerStats HAL 2.0 energy meter'
+ ODPM_MODEM_CHANNEL_NAME = '[VSYS_PWR_MODEM]:Modem'
+
+ # Key for custom_property in Sponge
+ CUSTOM_PROP_KEY_BUILD_ID = 'build_id'
+ CUSTOM_PROP_KEY_INCR_BUILD_ID = 'incremental_build_id'
+ CUSTOM_PROP_KEY_BUILD_TYPE = 'build_type'
+ CUSTOM_PROP_KEY_SYSTEM_POWER = 'system_power'
+ CUSTOM_PROP_KEY_MODEM_BASEBAND = 'baseband'
+ CUSTOM_PROP_KEY_MODEM_ODPM_POWER= 'modem_odpm_power'
+ CUSTOM_PROP_KEY_DEVICE_NAME = 'device'
+ CUSTOM_PROP_KEY_DEVICE_BUILD_PHASE = 'device_build_phase'
+ CUSTOM_PROP_KEY_MODEM_KIBBLE_POWER = 'modem_kibble_power'
+ CUSTOM_PROP_KEY_TEST_NAME = 'test_name'
+ CUSTOM_PROP_KEY_MODEM_KIBBLE_WO_PCIE_POWER = 'modem_kibble_power_wo_pcie'
+ CUSTOM_PROP_KEY_MODEM_KIBBLE_PCIE_POWER = 'modem_kibble_pcie_power'
+ CUSTOM_PROP_KEY_RFFE_POWER = 'rffe_power'
+ CUSTOM_PROP_KEY_MMWAVE_POWER = 'mmwave_power'
+ # kibble report
+ KIBBLE_SYSTEM_RECORD_NAME = '- name: default_device.C10_EVT_1_1.Monsoon:mA'
+ MODEM_PCIE_RAIL_NAME_LIST = [
+ 'PP1800_L2C_PCIEG3',
+ 'PP1200_L9C_PCIE',
+ 'PP0850_L8C_PCIE'
+ ]
+
+ MODEM_RFFE_RAIL_NAME_LIST = [
+ 'PP1200_L31C_RFFE',
+ 'VSYS_PWR_RFFE',
+ 'PP2800_L33C_RFFE'
+ ]
+
+ MODEM_POWER_RAIL_NAME = 'VSYS_PWR_MODEM'
+
+ MODEM_MMWAVE_RAIL_NAME = 'VSYS_PWR_MMWAVE'
+
+ MONSOON_RAIL_NAME = 'Monsoon'
+
+ # params key
+ MONSOON_VOLTAGE_KEY = 'mon_voltage'
+
+ MDSTEST_APP_APK_NAME = 'mdstest.apk'
+ ADB_CMD_INSTALL = 'install {apk_path}'
+ ADB_CMD_DISABLE_TXAS = 'am instrument -w -e request at+googtxas=2 -e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"'
+ ADB_CMD_SET_NV = ('am instrument -w '
+ '-e request at+googsetnv=\"{nv_name}\",{nv_index},\"{nv_value}\" '
+ '-e response wait "com.google.mdstest/com.google.mdstest.instrument.ModemATCommandInstrumentation"')
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.retryable_exceptions = signals.TestFailure
+ self.power_rails = {}
+ self.pcie_power = 0
+ self.rffe_power = 0
+ self.mmwave_power = 0
+ self.modem_power = 0
+ self.monsoon_power = 0
+
+ def setup_class(self):
+ super().setup_class()
+
+ # preset callbox
+ is_fr2 = 'Fr2' in self.TAG
+ self.cellular_simulator.switch_HCCU_settings(is_fr2=is_fr2)
+
+ self.at_util = AtUtil(self.cellular_dut.ad, self.log)
+
+ # preset UE.
+ self.log.info('Installing mdstest app.')
+ self.install_apk()
+
+ self.log.info('Disable antenna switch.')
+ is_txas_disabled = self.at_util.disable_txas()
+ self.log.info('Disable txas: ' + str(is_txas_disabled))
+
+ # get sim type
+ self.unpack_userparams(has_3gpp_sim=True)
+
+ def setup_test(self):
+ self.cellular_simulator.set_sim_type(self.has_3gpp_sim)
+ try:
+ if 'LTE' in self.test_name:
+ self.at_util.lock_LTE()
+ super().setup_test()
+ except BrokenPipeError:
+ self.log.info('TA crashed test need retry.')
+ self.need_retry = True
+ self.cellular_simulator.recovery_ta()
+ self.cellular_simulator.socket_connect()
+ raise signals.TestFailure('TA crashed mid test, retry needed.')
+ # except:
+ # # self.log.info('Waiting for device to on.')
+ # # self.dut.adb.wait_for_device()
+ # # self.cellular_dut = AndroidCellularDut.AndroidCellularDut(
+ # # self.android_devices[0], self.log)
+ # # self.dut.root_adb()
+ # # # Restart SL4A
+ # # self.dut.start_services()
+ # # self.need_retry = True
+ # raise signals.TestError('Device reboot mid test, retry needed.')
+
+ def install_apk(self):
+ sleep_time = 3
+ for file in self.custom_files:
+ if self.MDSTEST_APP_APK_NAME in file:
+ if not self.cellular_dut.ad.is_apk_installed("com.google.mdstest"):
+ self.cellular_dut.ad.adb.install("-r -g %s" % file, timeout=300, ignore_status=True)
+ time.sleep(sleep_time)
+ if self.cellular_dut.ad.is_apk_installed("com.google.mdstest"):
+ self.log.info('mdstest installed.')
+ else:
+ self.log.warning('fail to install mdstest.')
+
+ def set_nv(self, nv_name, index, value):
+ cmd = self.ADB_CMD_SET_NV.format(
+ nv_name=nv_name,
+ nv_index=index,
+ nv_value=value
+ )
+ response = str(self.cellular_dut.ad.adb.shell(cmd))
+ self.log.info(response)
+
+ def enable_ims_nr(self):
+ # set !NRCAPA.Gen.VoiceOverNr
+ self.set_nv(
+ nv_name = '!NRCAPA.Gen.VoiceOverNr',
+ index = '0',
+ value = '01'
+ )
+ # set PSS.AIMS.Enable.NRSACONTROL
+ self.set_nv(
+ nv_name = 'PSS.AIMS.Enable.NRSACONTROL',
+ index = '0',
+ value = '00'
+ )
+ # set DS.PSS.AIMS.Enable.NRSACONTROL
+ self.set_nv(
+ nv_name = 'DS.PSS.AIMS.Enable.NRSACONTROL',
+ index = '0',
+ value = '00'
+ )
+ if self.cellular_dut.ad.model == 'oriole':
+ # For P21, NR.CONFIG.MODE/DS.NR.CONFIG.MODE
+ self.set_nv(
+ nv_name = 'NR.CONFIG.MODE',
+ index = '0',
+ value = '11'
+ )
+ # set DS.NR.CONFIG.MODE
+ self.set_nv(
+ nv_name = 'DS.NR.CONFIG.MODE',
+ index = '0',
+ value = '11'
+ )
+ else:
+ # For P22, NASU.NR.CONFIG.MODE to 11
+ self.set_nv(
+ nv_name = 'NASU.NR.CONFIG.MODE',
+ index = '0',
+ value = '11'
+ )
+
+ def get_odpm_values(self):
+ """Get power measure from ODPM.
+
+ Parsing energy table in ODPM file
+ and convert to.
+ Returns:
+ odpm_power_results: a dictionary
+ has key as channel name,
+ and value as power measurement of that channel.
+ """
+ self.log.info('Start calculating power by channel from ODPM report.')
+ odpm_power_results = {}
+
+ # device before P21 don't have ODPM reading
+ if not self.odpm_folder:
+ return odpm_power_results
+
+ # getting ODPM modem power value
+ odpm_file_name = '{}.{}.dumpsys_odpm_{}.txt'.format(
+ self.__class__.__name__,
+ self.current_test_name,
+ 'after')
+ odpm_file_path = os.path.join(self.odpm_folder, odpm_file_name)
+ if os.path.exists(odpm_file_path):
+ elapsed_time = None
+ with open(odpm_file_path, 'r') as f:
+ # find energy table in ODPM report
+ for line in f:
+ if self.ODPM_ENERGY_TABLE_NAME in line:
+ break
+
+ # get elapse time 2 adb ODPM cmd (mS)
+ elapsed_time_str = f.readline()
+ elapsed_time = float(elapsed_time_str
+ .split(':')[1]
+ .strip()
+ .split(' ')[0])
+ self.log.info(elapsed_time_str)
+
+ # skip column name row
+ next(f)
+
+ # get power of different channel from odpm report
+ for line in f:
+ if 'End' in line:
+ break
+ else:
+ # parse columns
+ # example result of line.strip().split()
+ # ['[VSYS_PWR_DISPLAY]:Display', '1039108.42', 'mWs', '(', '344.69)']
+ channel, _, _, _, delta_str = line.strip().split()
+ delta = float(delta_str[:-2].strip())
+
+ # calculate OPDM power
+ # delta is a different in cumulative energy
+ # between 2 adb ODPM cmd
+ elapsed_time_s = elapsed_time / 1000
+ power = delta / elapsed_time_s
+ odpm_power_results[channel] = power
+ self.log.info(
+ channel + ' ' + str(power) + ' mW'
+ )
+ return odpm_power_results
+
+ def _is_any_substring(self, longer_word: str, word_list: List[str]) -> bool:
+ """Check if any word in word list a substring of a longer word."""
+ return any(w in longer_word for w in word_list)
+
+ def parse_power_rails_csv(self):
+ kibble_dir = os.path.join(self.root_output_path, 'Kibble')
+ kibble_csv_path = None
+ if os.path.exists(kibble_dir):
+ for f in os.listdir(kibble_dir):
+ if self.test_name in f and '.csv' in f:
+ kibble_csv_path = os.path.join(kibble_dir, f)
+ self.log.info('Kibble csv file path: ' + kibble_csv_path)
+ break
+
+ self.log.info('Parsing power rails from csv.')
+ if kibble_csv_path:
+ with open(kibble_csv_path, 'r') as f:
+ for line in f:
+ # railname,val,mA,val,mV,val,mW
+ railname, _, _, _, _, power, _ = line.split(',')
+ # parse pcie power
+ if self._is_any_substring(railname, self.MODEM_PCIE_RAIL_NAME_LIST):
+ self.log.info(railname + ': ' + power)
+ self.pcie_power += float(power)
+ elif self.MODEM_POWER_RAIL_NAME in railname:
+ self.log.info(railname + ': ' + power)
+ self.modem_power = float(power)
+ elif self._is_any_substring(railname, self.MODEM_RFFE_RAIL_NAME_LIST):
+ self.log.info(railname + ': ' + power)
+ self.rffe_power = float(power)
+ elif self.MODEM_MMWAVE_RAIL_NAME in railname:
+ self.log.info(railname + ': ' + power)
+ self.mmwave_power = float(power)
+ elif self.MONSOON_RAIL_NAME == railname:
+ self.log.info(railname + ': ' + power)
+ self.monsoon_power = float(power)
+ if self.modem_power:
+ self.power_results[self.test_name] = self.modem_power
+
+ def sponge_upload(self):
+ """Upload result to sponge as custom field."""
+ # test name
+ test_name_arr = self.current_test_name.split('_')
+ test_name_for_sponge = ''.join(
+ word[0].upper() + word[1:].lower()
+ for word in test_name_arr
+ if word not in ('preset', 'test')
+ )
+
+ # build info
+ build_info = self.cellular_dut.ad.build_info
+ build_id = build_info.get('build_id', 'Unknown')
+ incr_build_id = build_info.get('incremental_build_id', 'Unknown')
+ modem_base_band = self.cellular_dut.ad.adb.getprop(
+ 'gsm.version.baseband')
+ build_type = build_info.get('build_type', 'Unknown')
+
+ # device info
+ device_info = self.cellular_dut.ad.device_info
+ device_name = device_info.get('model', 'Unknown')
+ device_build_phase = self.cellular_dut.ad.adb.getprop(
+ 'ro.boot.hardware.revision'
+ )
+
+ # power measurement results
+ odpm_power_results = self.get_odpm_values()
+ odpm_power = odpm_power_results.get(self.ODPM_MODEM_CHANNEL_NAME, 0)
+ system_power = 0
+
+ # if kibbles are using, get power from kibble
+ modem_kibble_power_wo_pcie = 0
+ if hasattr(self, 'bitses'):
+ self.parse_power_rails_csv()
+ modem_kibble_power_wo_pcie = self.modem_power - self.pcie_power
+ system_power = self.monsoon_power
+ else:
+ system_power = self.power_results.get(self.test_name, 0)
+
+ self.record_data({
+ 'Test Name': self.test_name,
+ 'sponge_properties': {
+ self.CUSTOM_PROP_KEY_SYSTEM_POWER: system_power,
+ self.CUSTOM_PROP_KEY_BUILD_ID: build_id,
+ self.CUSTOM_PROP_KEY_INCR_BUILD_ID: incr_build_id,
+ self.CUSTOM_PROP_KEY_MODEM_BASEBAND: modem_base_band,
+ self.CUSTOM_PROP_KEY_BUILD_TYPE: build_type,
+ self.CUSTOM_PROP_KEY_MODEM_ODPM_POWER: odpm_power,
+ self.CUSTOM_PROP_KEY_DEVICE_NAME: device_name,
+ self.CUSTOM_PROP_KEY_DEVICE_BUILD_PHASE: device_build_phase,
+ self.CUSTOM_PROP_KEY_MODEM_KIBBLE_POWER: self.modem_power,
+ self.CUSTOM_PROP_KEY_TEST_NAME: test_name_for_sponge,
+ self.CUSTOM_PROP_KEY_MODEM_KIBBLE_WO_PCIE_POWER: modem_kibble_power_wo_pcie,
+ self.CUSTOM_PROP_KEY_MODEM_KIBBLE_PCIE_POWER: self.pcie_power,
+ self.CUSTOM_PROP_KEY_RFFE_POWER: self.rffe_power,
+ self.CUSTOM_PROP_KEY_MMWAVE_POWER: self.mmwave_power
+ },
+ })
+
+ def teardown_test(self):
+ super().teardown_test()
+ # restore device to ready state for next test
+ self.log.info('Enable mobile data.')
+ self.dut.adb.shell('svc data enable')
+ self.cellular_simulator.detach()
+ self.cellular_dut.toggle_airplane_mode(True)
+
+ # processing result
+ self.sponge_upload()
+ if 'LTE' in self.test_name:
+ self.at_util.clear_lock_band()
\ No newline at end of file
diff --git a/acts_tests/acts_contrib/test_utils/power/cellular/ims_api_connector_utils.py b/acts_tests/acts_contrib/test_utils/power/cellular/ims_api_connector_utils.py
new file mode 100644
index 0000000..cfdc67a
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/power/cellular/ims_api_connector_utils.py
@@ -0,0 +1,228 @@
+# TODO(hmtuan): add type annotation.
+import requests
+import time
+
+class ImsApiConnector():
+ """A wrapper class for Keysight Ims API Connector.
+
+ Keysight provided an API connector application
+ which is a HTTP server running on the same host
+ as Keysight IMS server simulator and client simulator.
+ It allows IMS simulator/app to be controlled via HTTP request.
+
+ Attributes:
+ api_connector_ip: ip of http server.
+ api_connector_port: port of http server.
+ ims_app: type of ims app (client/server).
+ api_token: an arbitrary and unique token-string
+ to identify the link between API connector
+ and ims app.
+ log: logger object.
+ """
+
+ def __init__(self, api_connector_ip,
+ api_connector_port, ims_app,
+ api_token, ims_app_ip,
+ ims_app_port, log):
+ # api connector info
+ self.api_connector_ip = api_connector_ip
+ self.api_connector_port = api_connector_port
+
+ # ims app info
+ self.ims_app = ims_app
+ self.api_token = api_token
+ self.ims_app_ip = ims_app_ip
+ self.ims_app_port = ims_app_port
+
+ self.log = log
+ # construct base url
+ self.base_url = 'http://{addr}:{port}/ims/api/{app}s/{api_token}'.format(
+ addr = self.api_connector_ip,
+ port = self.api_connector_port,
+ app = self.ims_app,
+ api_token = self.api_token
+ )
+
+ def get_base_url(self):
+ return self.base_url
+
+ def create_ims_app_link(self):
+ """Create link between Keysight API Connector to ims app."""
+ self.log.info('Create ims app link: token:ip:port')
+ self.log.info('Creating ims_{app} link: {token}:{target_ip}:{target_port}'.format(
+ app = self.ims_app,
+ token = self.api_token,
+ target_ip = self.ims_app_ip,
+ target_port= self.ims_app_port)
+ )
+
+ request_data = {
+ "targetIpAddress": self.ims_app_ip,
+ "targetWcfPort": self.ims_app_port
+ }
+ self.log.debug(f'Payload to create ims app link: {request_data}')
+ r = requests.post(url = self.get_base_url(), json = request_data)
+
+ self.log.info('HTTP request sent:')
+ self.log.info('-> method: ' + str(r.request.method))
+ self.log.info('-> url: ' + str(r.url))
+ self.log.info('-> status_code: ' + str(r.status_code))
+
+ return (r.status_code == 201)
+
+ def remove_ims_app_link(self):
+ """Remove link between Keysight API Connector to ims app."""
+ self.log.info('Remove ims_{app} link: {token}'.format(
+ app = self.ims_app,
+ token = self.api_token)
+ )
+
+ r = requests.delete(url = self.get_base_url())
+
+ self.log.info('-> method: ' + str(r.request.method))
+ self.log.info('-> url: ' + str(r.url))
+ self.log.info('-> status_code: ' + str(r.status_code))
+
+ return (r.status_code == 200)
+
+ def get_ims_app_property(self, property_name):
+ """Get property value of IMS app.
+
+ Attributes:
+ property_name: name of property to get value.
+ """
+ self.log.info('Getting ims app property: ' + property_name)
+
+ request_url = self.get_base_url() + '/get_property'
+ request_params = {"propertyName": property_name}
+ r = requests.get(url = request_url, params = request_params)
+
+ self.log.info('-> method: ' + str(r.request.method))
+ self.log.info('-> url: ' + str(r.url))
+ self.log.info('-> status_code: ' + str(r.status_code))
+
+ try:
+ res_json = r.json()
+ except:
+ res_json = {'propertyValue': None }
+ prop_value = res_json['propertyValue']
+
+ return prop_value
+
+ def set_ims_app_property(self, property_name, property_value):
+ """Set property value of IMS app.
+
+ Attributes:
+ property_name: name of property to set value.
+ property_value: value to be set.
+ """
+ self.log.info('Setting ims property: ' + property_name + ' = ' + str(property_value))
+
+ request_url = self.get_base_url() + '/set_property'
+ data = {
+ 'propertyName': property_name,
+ 'propertyValue': property_value
+ }
+ r = requests.post(url = request_url, json = data)
+
+ self.log.info('-> method: ' + str(r.request.method))
+ self.log.info('-> url: ' + str(r.url))
+ self.log.info('-> status_code: ' + str(r.status_code))
+
+ return (r.status_code == 200)
+
+ def ims_api_call_method(self, method_name, method_args=None):
+ """
+ Attributes:
+ method_name: a name of method from Keysight API in string.
+ method_args: a python-array contains
+ arguments for the called API method.
+ Returns:
+ a tuple of (STATUS_BOOL, FUNC_RET_VAL),
+ if STATUS_BOOL is false, FUNC_RET_VAL is questionable/undefined,
+ if STATUS_BOOL is true, FUNC_RET_VAL will be the API function return value
+ or FUNC_RET_VAL is None if the called method return nothing.
+ """
+ self.log.info('Calling ims method: ' + method_name)
+
+ if (method_args == None):
+ method_args = []
+ elif (type(method_args) != list):
+ method_args = [method_args]
+ data = {
+ 'methodName': method_name,
+ 'arguments': method_args
+ }
+ request_url = self.get_base_url() + '/call_method'
+ r = requests.post(url = request_url, json = data)
+
+ ret_val = None
+
+ if ( ('Content-Type' in r.headers.keys()) and r.headers['Content-Type'] == 'application/json'):
+ # TODO(hmtuan): try json.loads() instead
+ response_body = r.json()
+ if ((response_body != None) and ('returnValue' in response_body.keys())) :
+ ret_val = response_body['returnValue']
+
+ self.log.info('-> method: ' + str(r.request.method))
+ self.log.info('-> url: ' + str(r.url))
+ self.log.info('-> status_code: ' + str(r.status_code))
+ self.log.info('-> ret_val: ' + str(ret_val))
+
+ return (r.status_code == 200), ret_val
+
+ def _is_line_idle(self, call_line_number):
+ is_line_idle_prop = self.get_ims_app_property(
+ f'IVoip.CallLineParams({call_line_number}).SessionState')
+ return is_line_idle_prop == 'Idle'
+
+ def _is_ims_client_app_registered(self):
+ is_registered_prop = self.get_ims_app_property('IComponentControl.IsRegistered')
+ return is_registered_prop == 'True'
+
+ def initiate_call(self, callee_number, call_line_idx=0):
+ """Dial to callee_number.
+
+ Attributes:
+ callee_number: number to be dialed to.
+ """
+ # create IMS-Client API link
+ ret_val = self.create_ims_app_link()
+
+ if not ret_val:
+ raise RuntimeError('Fail to create link to IMS app.')
+
+ # check if IMS-Client is registered, and if not, request client to perform Registration
+ self.log.info('Ensuring client registered.')
+ is_registered = self._is_ims_client_app_registered()
+ if not is_registered:
+ self.log.info('Client not currently registered - registering.')
+ self.ims_api_call_method('ISipConnection.Register()')
+
+ is_registered = self._is_ims_client_app_registered()
+ if not is_registered:
+ raise RuntimeError('Failed to register IMS-client to IMS-server.')
+
+ # switch to call-line #1 (idx = 0)
+ self.log.info('Switching to call-line #1.')
+ self.set_ims_app_property('IVoip.SelectedCallLine', call_line_idx)
+
+ # check whether the call-line #1 is ready for dialling
+ is_line1_idle = self._is_line_idle(call_line_idx)
+ if not is_line1_idle:
+ raise RuntimeError('Call-line not is not in indle state.')
+
+ # entering callee number for call-line #1
+ self.log.info(f'Enter callee number: {callee_number}.')
+ self.set_ims_app_property('IVoip.CallLineParams(0).CallLocation', callee_number)
+
+ # dial entered callee number
+ self.log.info('Dialling call.')
+ self.ims_api_call_method('IVoip.Dial()')
+
+ time.sleep(5)
+
+ # check if dial success (not idle)
+ is_line1_idle = self._is_line_idle(call_line_idx)
+ if is_line1_idle:
+ raise RuntimeError('Fail to dial.')
diff --git a/acts_tests/acts_contrib/test_utils/wifi/aware/aware_const.py b/acts_tests/acts_contrib/test_utils/wifi/aware/aware_const.py
index f0f385b..3226263 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/aware/aware_const.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/aware/aware_const.py
@@ -61,6 +61,7 @@
DISCOVERY_KEY_RANGING_ENABLED = "RangingEnabled"
DISCOVERY_KEY_MIN_DISTANCE_MM = "MinDistanceMm"
DISCOVERY_KEY_MAX_DISTANCE_MM = "MaxDistanceMm"
+DISCOVERY_KEY_INSTANT_COMMUNICATION_MODE = "InstantModeEnabled"
PUBLISH_TYPE_UNSOLICITED = 0
PUBLISH_TYPE_SOLICITED = 1
@@ -150,6 +151,7 @@
CAP_MAX_QUEUED_TRANSMIT_MESSAGES = "maxQueuedTransmitMessages"
CAP_MAX_SUBSCRIBE_INTERFACE_ADDRESSES = "maxSubscribeInterfaceAddresses"
CAP_SUPPORTED_CIPHER_SUITES = "supportedCipherSuites"
+CAP_SUPPORTED_INSTANT_COMMUNICATION_MODE = "isInstantCommunicationModeSupported"
######################################################
# WifiAwareNetworkCapabilities keys
diff --git a/acts_tests/acts_contrib/test_utils/wifi/aware/aware_test_utils.py b/acts_tests/acts_contrib/test_utils/wifi/aware/aware_test_utils.py
index 4f22289..06b2e04 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/aware/aware_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/aware/aware_test_utils.py
@@ -714,7 +714,8 @@
match_filter=None,
match_filter_list=None,
ttl=0,
- term_cb_enable=True):
+ term_cb_enable=True,
+ instant_mode=None):
"""Create a publish discovery configuration based on input parameters.
Args:
@@ -726,6 +727,7 @@
ttl: Time-to-live - defaults to 0 (i.e. non-self terminating)
term_cb_enable: True (default) to enable callback on termination, False
means that no callback is called when session terminates.
+ instant_mode: set the band to use instant communication mode, 2G or 5G
Returns:
publish discovery configuration object.
"""
@@ -738,6 +740,8 @@
config[aconsts.DISCOVERY_KEY_MATCH_FILTER] = match_filter
if match_filter_list is not None:
config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = match_filter_list
+ if instant_mode is not None:
+ config[aconsts.DISCOVERY_KEY_INSTANT_COMMUNICATION_MODE] = instant_mode
config[aconsts.DISCOVERY_KEY_TTL] = ttl
config[aconsts.DISCOVERY_KEY_TERM_CB_ENABLED] = term_cb_enable
return config
diff --git a/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py b/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py
index d74e785..280e72e 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py
@@ -16,6 +16,7 @@
import contextlib
import io
+import requests
import serial
import time
from acts import logger
@@ -52,6 +53,7 @@
Base class provides functions whose implementation is shared by all
chambers.
"""
+
def reset_chamber(self):
"""Resets the chamber to its zero/home state."""
raise NotImplementedError
@@ -83,6 +85,7 @@
class MockChamber(OtaChamber):
"""Class that implements mock chamber for test development and debug."""
+
def __init__(self, config):
self.config = config.copy()
self.device_id = self.config['device_id']
@@ -120,6 +123,7 @@
class OctoboxChamber(OtaChamber):
"""Class that implements Octobox chamber."""
+
def __init__(self, config):
self.config = config.copy()
self.device_id = self.config['device_id']
@@ -129,7 +133,9 @@
utils.exe_cmd('sudo {} -d {} -i 0'.format(self.TURNTABLE_FILE_PATH,
self.device_id))
self.current_mode = None
- self.SUPPORTED_BANDS = ['2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3', '6GHz']
+ self.SUPPORTED_BANDS = [
+ '2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3', 'UNII-4', '6GHz'
+ ]
def set_orientation(self, orientation):
self.log.info('Setting orientation to {} degrees.'.format(orientation))
@@ -142,12 +148,49 @@
self.set_orientation(0)
+class OctoboxChamberV2(OtaChamber):
+ """Class that implements Octobox chamber."""
+
+ def __init__(self, config):
+ self.config = config.copy()
+ self.address = config['ip_address']
+ self.data = requests.get("http://{}/api/turntable".format(
+ self.address))
+ self.vel_target = '10000'
+ self.current_mode = None
+ self.SUPPORTED_BANDS = [
+ '2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3', 'UNII-4', '6GHz'
+ ]
+ self.log = logger.create_tagged_trace_logger('OtaChamber|{}'.format(
+ self.address))
+
+ def set_orientation(self, orientation):
+ self.log.info('Setting orientation to {} degrees.'.format(orientation))
+ if orientation > 720:
+ raise ValueError('Orientation may not exceed 720.')
+ set_position_submission = {
+ "action": "pos",
+ "enable": "1",
+ "pos_target": orientation,
+ "vel_target": self.vel_target
+ }
+ result = requests.post("http://{}/api/turntable".format(self.address),
+ json=set_position_submission)
+ self.log.debug(result)
+
+ def reset_chamber(self):
+ self.log.info('Resetting chamber to home state')
+ self.set_orientation(0)
+
+
class ChamberAutoConnect(object):
+
def __init__(self, chamber, chamber_config):
self._chamber = chamber
self._config = chamber_config
def __getattr__(self, item):
+
def chamber_call(*args, **kwargs):
self._chamber.connect(self._config['ip_address'],
self._config['username'],
@@ -159,6 +202,7 @@
class BluetestChamber(OtaChamber):
"""Class that implements Octobox chamber."""
+
def __init__(self, config):
import flow
self.config = config.copy()
@@ -167,7 +211,9 @@
self.chamber = ChamberAutoConnect(flow.Flow(), self.config)
self.stirrer_ids = [0, 1, 2]
self.current_mode = None
- self.SUPPORTED_BANDS = ['2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3']
+ self.SUPPORTED_BANDS = [
+ '2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3', 'UNII-4', '6GHz'
+ ]
# Capture print output decorator
@staticmethod
@@ -248,6 +294,7 @@
class EInstrumentChamber(OtaChamber):
"""Class that implements Einstrument Chamber."""
+
def __init__(self, config):
self.config = config.copy()
self.device_id = self.config['device_id']
diff --git a/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py b/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py
index 395fed2..7cc52da 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py
@@ -18,6 +18,7 @@
import os
import posixpath
import time
+import zipfile
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
from acts import context
@@ -126,6 +127,7 @@
class MockSniffer(OtaSnifferBase):
"""Class that implements mock sniffer for test development and debug."""
+
def __init__(self, config):
self.log = logger.create_tagged_trace_logger('Mock Sniffer')
@@ -443,6 +445,11 @@
if self.sniffer_output_file_type == 'csv':
log_file = self._process_tshark_dump(log_file)
+ if self.sniffer_output_file_type == 'pcap':
+ zip_file_path = log_file[:-4] + "zip"
+ zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED).write(
+ log_file, arcname=log_file.split('/')[-1])
+ os.remove(log_file)
self.sniffer_proc_pid = None
return log_file
@@ -450,6 +457,7 @@
class TsharkSnifferOnUnix(TsharkSnifferBase):
"""Class that implements Tshark based sniffer controller on Unix systems."""
+
def _scan_for_networks(self):
"""Scans the wireless networks on the sniffer.
@@ -480,6 +488,7 @@
class TsharkSnifferOnLinux(TsharkSnifferBase):
"""Class that implements Tshark based sniffer controller on Linux."""
+
def __init__(self, config):
super().__init__(config)
self._init_sniffer()
diff --git a/acts_tests/acts_contrib/test_utils/wifi/p2p/wifi_p2p_test_utils.py b/acts_tests/acts_contrib/test_utils/wifi/p2p/wifi_p2p_test_utils.py
index b5832d0..10f3ea0 100755
--- a/acts_tests/acts_contrib/test_utils/wifi/p2p/wifi_p2p_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/p2p/wifi_p2p_test_utils.py
@@ -339,7 +339,6 @@
while not p2p_find_result:
ad2.droid.wifiP2pStopPeerDiscovery()
ad1.droid.wifiP2pStopPeerDiscovery()
- ad2.droid.wifiP2pDiscoverPeers()
ad1.droid.wifiP2pDiscoverPeers()
ad1_event = ad1.ed.pop_event(p2pconsts.PEER_AVAILABLE_EVENT,
p2pconsts.P2P_FIND_TIMEOUT)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/__init__.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/__init__.py
index 831ddc8..9da3529 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/__init__.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/__init__.py
@@ -66,7 +66,7 @@
def detect_wifi_platform(dut):
if hasattr(dut, 'wifi_platform'):
return dut.wifi_platform
- qcom_check = len(dut.get_file_names('/vendor/firmware/wlan/qca_cld/'))
+ qcom_check = len(dut.get_file_names('/vendor/firmware/wlan/'))
if qcom_check:
dut.wifi_platform = 'qcom'
else:
@@ -75,6 +75,7 @@
def detect_wifi_decorator(f):
+
def wrap(*args, **kwargs):
if 'dut' in kwargs:
dut = kwargs['dut']
@@ -274,7 +275,8 @@
socket_size=None,
num_processes=1,
udp_throughput='1000M',
- ipv6=False):
+ ipv6=False,
+ udp_length=1470):
"""Function to format iperf client arguments.
This function takes in iperf client parameters and returns a properly
@@ -296,8 +298,8 @@
if ipv6:
iperf_args = iperf_args + '-6 '
if traffic_type.upper() == 'UDP':
- iperf_args = iperf_args + '-u -b {} -l 1470 -P {} '.format(
- udp_throughput, num_processes)
+ iperf_args = iperf_args + '-u -b {} -l {} -P {} '.format(
+ udp_throughput, udp_length, num_processes)
elif traffic_type.upper() == 'TCP':
iperf_args = iperf_args + '-P {} '.format(num_processes)
if socket_size:
@@ -728,6 +730,7 @@
# Link layer stats utilities
class LinkLayerStats():
+
def __new__(self, dut, llstats_enabled=True):
if detect_wifi_platform(dut) == 'qcom':
return qcom_utils.LinkLayerStats(dut, llstats_enabled)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/bokeh_figure.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/bokeh_figure.py
index 5a8433e..d91803b 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/bokeh_figure.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/bokeh_figure.py
@@ -19,6 +19,7 @@
import itertools
import json
import math
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
# Plotting Utilities
@@ -98,8 +99,8 @@
def init_plot(self):
self.plot = bokeh.plotting.figure(
sizing_mode=self.fig_property['sizing_mode'],
- plot_width=self.fig_property['width'],
- plot_height=self.fig_property['height'],
+ width=self.fig_property['width'],
+ height=self.fig_property['height'],
title=self.fig_property['title'],
tools=self.TOOLS,
x_axis_type=self.fig_property['x_axis_type'],
@@ -326,7 +327,7 @@
figure_data=self.figure_data)
output_file = output_file.replace('.html', '_plot_data.json')
with open(output_file, 'w') as outfile:
- json.dump(figure_dict, outfile, indent=4)
+ json.dump(wputils.serialize_dict(figure_dict), outfile, indent=4)
def save_figure(self, output_file, save_json=True):
"""Function to save BokehFigure.
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/brcm_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/brcm_utils.py
index afa5f32..fe2d3e7 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/brcm_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/brcm_utils.py
@@ -378,16 +378,17 @@
LL_STATS_CLEAR_CMD = 'wl dump_clear ampdu; wl reset_cnts;'
BW_REGEX = re.compile(r'Chanspec:.+ (?P<bandwidth>[0-9]+)MHz')
MCS_REGEX = re.compile(r'(?P<count>[0-9]+)\((?P<percent>[0-9]+)%\)')
- RX_REGEX = re.compile(r'RX (?P<mode>\S+)\s+:\s*(?P<nss1>[0-9, ,(,),%]*)'
- '\n\s*:?\s*(?P<nss2>[0-9, ,(,),%]*)')
- TX_REGEX = re.compile(r'TX (?P<mode>\S+)\s+:\s*(?P<nss1>[0-9, ,(,),%]*)'
- '\n\s*:?\s*(?P<nss2>[0-9, ,(,),%]*)')
+ RX_REGEX = re.compile(
+ r'RX (?P<mode>MCS|VHT|HE|EHT)\s+:\s*(?P<nss1>[0-9, ,(,),%]*)'
+ '\n\s*:?\s*(?P<nss2>[0-9, ,(,),%]*)')
+ TX_REGEX = re.compile(
+ r'TX (?P<mode>MCS|VHT|HE|EHT)\s+:\s*(?P<nss1>[0-9, ,(,),%]*)'
+ '\n\s*:?\s*(?P<nss2>[0-9, ,(,),%]*)')
TX_PER_REGEX = re.compile(
r'(?P<mode>\S+) PER\s+:\s*(?P<nss1>[0-9, ,(,),%]*)'
'\n\s*:?\s*(?P<nss2>[0-9, ,(,),%]*)')
- RX_FCS_REGEX = re.compile(
- r'rxbadfcs (?P<rx_bad_fcs>[0-9]*).+\n.+goodfcs (?P<rx_good_fcs>[0-9]*)'
- )
+ RX_GOOD_FCS_REGEX = re.compile(r'goodfcs (?P<rx_good_fcs>[0-9]*)')
+ RX_BAD_FCS_REGEX = re.compile(r'rxbadfcs (?P<rx_bad_fcs>[0-9]*)')
RX_AGG_REGEX = re.compile(r'rxmpduperampdu (?P<aggregation>[0-9]*)')
TX_AGG_REGEX = re.compile(r' mpduperampdu (?P<aggregation>[0-9]*)')
TX_AGG_STOP_REGEX = re.compile(
@@ -405,6 +406,7 @@
self.llstats_enabled = llstats_enabled
self.llstats_cumulative = self._empty_llstats()
self.llstats_incremental = self._empty_llstats()
+ self.bandwidth = None
def update_stats(self):
if self.llstats_enabled:
@@ -414,8 +416,9 @@
self.dut.adb.shell_nb(self.LL_STATS_CLEAR_CMD)
wl_join = self.dut.adb.shell("wl status")
- self.bandwidth = int(
- re.search(self.BW_REGEX, wl_join).group('bandwidth'))
+ if not self.bandwidth:
+ self.bandwidth = int(
+ re.search(self.BW_REGEX, wl_join).group('bandwidth'))
except:
llstats_output = ''
else:
@@ -494,33 +497,32 @@
rx_agg_match = re.search(self.RX_AGG_REGEX, llstats_output)
tx_agg_match = re.search(self.TX_AGG_REGEX, llstats_output)
tx_agg_stop_match = re.search(self.TX_AGG_STOP_REGEX, llstats_output)
- rx_fcs_match = re.search(self.RX_FCS_REGEX, llstats_output)
+ rx_good_fcs_match = re.search(self.RX_GOOD_FCS_REGEX, llstats_output)
+ rx_bad_fcs_match = re.search(self.RX_BAD_FCS_REGEX, llstats_output)
- if rx_agg_match and tx_agg_match and tx_agg_stop_match and rx_fcs_match:
- agg_stop_dict = collections.OrderedDict(
- rx_aggregation=int(rx_agg_match.group('aggregation')),
- tx_aggregation=int(tx_agg_match.group('aggregation')),
- tx_agg_tried=int(tx_agg_stop_match.group('agg_tried')),
- tx_agg_canceled=int(tx_agg_stop_match.group('agg_canceled')),
- rx_good_fcs=int(rx_fcs_match.group('rx_good_fcs')),
- rx_bad_fcs=int(rx_fcs_match.group('rx_bad_fcs')),
- agg_stop_reason=collections.OrderedDict())
+ mpdu_stats = collections.OrderedDict(
+ rx_aggregation=int(rx_agg_match.group('aggregation'))
+ if rx_agg_match else 0,
+ tx_aggregation=int(tx_agg_match.group('aggregation'))
+ if tx_agg_match else 0,
+ tx_agg_tried=int(tx_agg_stop_match.group('agg_tried'))
+ if tx_agg_stop_match else 0,
+ tx_agg_canceled=int(tx_agg_stop_match.group('agg_canceled'))
+ if tx_agg_stop_match else 0,
+ rx_good_fcs=int(rx_good_fcs_match.group('rx_good_fcs'))
+ if rx_good_fcs_match else 0,
+ rx_bad_fcs=int(rx_bad_fcs_match.group('rx_bad_fcs'))
+ if rx_bad_fcs_match else 0,
+ agg_stop_reason=collections.OrderedDict())
+ if tx_agg_stop_match:
agg_reason_match = re.finditer(
self.TX_AGG_STOP_REASON_REGEX,
tx_agg_stop_match.group('agg_stop_reason'))
for reason_match in agg_reason_match:
- agg_stop_dict['agg_stop_reason'][reason_match.group(
+ mpdu_stats['agg_stop_reason'][reason_match.group(
'reason')] = reason_match.group('value')
- else:
- agg_stop_dict = collections.OrderedDict(rx_aggregation=0,
- tx_aggregation=0,
- tx_agg_tried=0,
- tx_agg_canceled=0,
- rx_good_fcs=0,
- rx_bad_fcs=0,
- agg_stop_reason=None)
- return agg_stop_dict
+ return mpdu_stats
def _generate_stats_summary(self, llstats_dict):
llstats_summary = collections.OrderedDict(common_tx_mcs=None,
@@ -547,13 +549,17 @@
llstats_summary['common_tx_mcs_count'] = numpy.max(tx_mpdu)
llstats_summary['common_rx_mcs'] = mcs_ids[numpy.argmax(rx_mpdu)]
llstats_summary['common_rx_mcs_count'] = numpy.max(rx_mpdu)
- if sum(tx_mpdu) and sum(rx_mpdu):
+ if sum(tx_mpdu):
llstats_summary['mean_tx_phy_rate'] = numpy.average(
phy_rates, weights=tx_mpdu)
- llstats_summary['mean_rx_phy_rate'] = numpy.average(
- phy_rates, weights=rx_mpdu)
llstats_summary['common_tx_mcs_freq'] = (
llstats_summary['common_tx_mcs_count'] / sum(tx_mpdu))
+ else:
+ llstats_summary['mean_tx_phy_rate'] = 0
+ llstats_summary['common_tx_mcs_freq'] = 0
+ if sum(rx_mpdu):
+ llstats_summary['mean_rx_phy_rate'] = numpy.average(
+ phy_rates, weights=rx_mpdu)
llstats_summary['common_rx_mcs_freq'] = (
llstats_summary['common_rx_mcs_count'] / sum(rx_mpdu))
total_rx_frames = llstats_dict['mpdu_stats'][
@@ -561,7 +567,11 @@
if total_rx_frames:
llstats_summary['rx_per'] = (
llstats_dict['mpdu_stats']['rx_bad_fcs'] /
- (total_rx_frames)) * 100
+ total_rx_frames) * 100
+ else:
+ llstats_summary['mean_rx_phy_rate'] = 0
+ llstats_summary['common_rx_mcs_freq'] = 0
+ llstats_summary['rx_per'] = 0
return llstats_summary
def _update_stats(self, llstats_output):
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/qcom_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/qcom_utils.py
index 53321bc..f29e4fa 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/qcom_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/qcom_utils.py
@@ -21,6 +21,7 @@
import os
import re
import statistics
+import numpy
import time
from acts import asserts
@@ -275,14 +276,15 @@
def _edit_dut_ini(dut, ini_fields):
"""Function to edit Wifi ini files."""
- dut_ini_path = '/vendor/firmware/wlan/qca_cld/WCNSS_qcom_cfg.ini'
- local_ini_path = os.path.expanduser('~/WCNSS_qcom_cfg.ini')
+ dut_ini_path = '/vendor/firmware/wlan/qcom_cfg.ini'
+ local_ini_path = os.path.expanduser('~/qcom_cfg.ini')
dut.pull_files(dut_ini_path, local_ini_path)
_set_ini_fields(local_ini_path, ini_fields)
dut.push_system_file(local_ini_path, dut_ini_path)
- dut.reboot()
+ # For 1x1 mode, we need to wait for sl4a to load (To avoid crashes)
+ dut.reboot(timeout=300, wait_after_reboot_complete=120)
def set_chain_mask(dut, chain_mask):
@@ -336,6 +338,7 @@
class LinkLayerStats():
LLSTATS_CMD = 'cat /d/wlan0/ll_stats'
+ MOUNT_CMD = 'mount -t debugfs debugfs /sys/kernel/debug'
PEER_REGEX = 'LL_STATS_PEER_ALL'
MCS_REGEX = re.compile(
r'preamble: (?P<mode>\S+), nss: (?P<num_streams>\S+), bw: (?P<bw>\S+), '
@@ -345,8 +348,8 @@
'retries_long: (?P<retries_long>\S+)')
MCS_ID = collections.namedtuple(
'mcs_id', ['mode', 'num_streams', 'bandwidth', 'mcs', 'rate'])
- MODE_MAP = {'0': '11a/g', '1': '11b', '2': '11n', '3': '11ac'}
- BW_MAP = {'0': 20, '1': 40, '2': 80}
+ MODE_MAP = {'0': '11a/g', '1': '11b', '2': '11n', '3': '11ac', '4': '11ax'}
+ BW_MAP = {'0': 20, '1': 40, '2': 80, '3':160}
def __init__(self, dut, llstats_enabled=True):
self.dut = dut
@@ -356,6 +359,12 @@
def update_stats(self):
if self.llstats_enabled:
+ # Checking the files to see if the device is mounted to enable
+ # llstats capture
+ mount_check = len(self.dut.get_file_names('/d/wlan0'))
+ if not(mount_check):
+ self.dut.adb.shell(self.MOUNT_CMD, timeout=10)
+
try:
llstats_output = self.dut.adb.shell(self.LLSTATS_CMD,
timeout=0.1)
@@ -400,7 +409,7 @@
current_mcs = self.MCS_ID(self.MODE_MAP[match.group('mode')],
int(match.group('num_streams')) + 1,
self.BW_MAP[match.group('bw')],
- int(match.group('mcs')),
+ int(match.group('mcs'), 16),
int(match.group('rate'), 16) / 1000)
current_stats = collections.OrderedDict(
txmpdu=int(match.group('txmpdu')),
@@ -427,9 +436,17 @@
common_rx_mcs_freq=0,
rx_per=float('nan'))
+ phy_rates=[]
+ tx_mpdu=[]
+ rx_mpdu=[]
txmpdu_count = 0
rxmpdu_count = 0
for mcs_id, mcs_stats in llstats_dict['mcs_stats'].items():
+ # Extract the phy-rates
+ mcs_id_split=mcs_id.split();
+ phy_rates.append(float(mcs_id_split[len(mcs_id_split)-1].split('M')[0]))
+ rx_mpdu.append(mcs_stats['rxmpdu'])
+ tx_mpdu.append(mcs_stats['txmpdu'])
if mcs_stats['txmpdu'] > llstats_summary['common_tx_mcs_count']:
llstats_summary['common_tx_mcs'] = mcs_id
llstats_summary['common_tx_mcs_count'] = mcs_stats['txmpdu']
@@ -438,6 +455,15 @@
llstats_summary['common_rx_mcs_count'] = mcs_stats['rxmpdu']
txmpdu_count += mcs_stats['txmpdu']
rxmpdu_count += mcs_stats['rxmpdu']
+
+ if len(tx_mpdu) == 0 or len(rx_mpdu) == 0:
+ return llstats_summary
+
+ # Calculate the average tx/rx -phy rates
+ if sum(tx_mpdu) and sum(rx_mpdu):
+ llstats_summary['mean_tx_phy_rate'] = numpy.average(phy_rates, weights=tx_mpdu)
+ llstats_summary['mean_rx_phy_rate'] = numpy.average(phy_rates, weights=rx_mpdu)
+
if txmpdu_count:
llstats_summary['common_tx_mcs_freq'] = (
llstats_summary['common_tx_mcs_count'] / txmpdu_count)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_power_test_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_power_test_utils.py
index adefa7e..3063423 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_power_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_power_test_utils.py
@@ -33,6 +33,24 @@
ENABLED_MODULATED_DTIM = 'gEnableModulatedDTIM='
MAX_MODULATED_DTIM = 'gMaxLIModulatedDTIM='
+CHRE_WIFI_SCAN_TYPE = {
+ 'active': 'active',
+ 'passive': 'passive',
+ 'activePassiveDfs': 'active_passive_dfs',
+ 'noPreference': 'no_preference'
+}
+
+CHRE_WIFI_RADIO_CHAIN = {
+ 'lowLatency': 'low_latency',
+ 'lowPower': 'low_power',
+ 'highAccuracy': 'high_accuracy'
+}
+
+CHRE_WIFI_CHANNEL_SET = {
+ 'all': 'all',
+ 'nonDfs': 'non_dfs'
+}
+
def change_dtim(ad, gEnableModulatedDTIM, gMaxLIModulatedDTIM=10):
"""Function to change the DTIM setting in the phone.
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/__init__.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/__init__.py
index 214401c..da47cb8 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/__init__.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/__init__.py
@@ -18,11 +18,17 @@
import copy
import fcntl
import importlib
+import logging
import os
import selenium
-import splinter
import time
from acts import logger
+from selenium.webdriver.support.ui import Select
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as expected_conditions
+from webdriver_manager.chrome import ChromeDriverManager
+
BROWSER_WAIT_SHORT = 1
BROWSER_WAIT_MED = 3
@@ -106,7 +112,7 @@
obj.teardown()
-class BlockingBrowser(splinter.driver.webdriver.chrome.WebDriver):
+class BlockingBrowser(selenium.webdriver.chrome.webdriver.WebDriver):
"""Class that implements a blocking browser session on top of selenium.
The class inherits from and builds upon splinter/selenium's webdriver class
@@ -123,10 +129,14 @@
headless: boolean to control visible/headless browser operation
timeout: maximum time allowed to launch browser
"""
+ if int(selenium.__version__[0]) < 4:
+ raise RuntimeError(
+ 'BlockingBrowser now requires selenium==4.0.0 or later. ')
self.log = logger.create_tagged_trace_logger('ChromeDriver')
- self.chrome_options = splinter.driver.webdriver.chrome.Options()
+ self.chrome_options = selenium.webdriver.chrome.webdriver.Options()
self.chrome_options.add_argument('--no-proxy-server')
self.chrome_options.add_argument('--no-sandbox')
+ self.chrome_options.add_argument('--crash-dumps-dir=/tmp')
self.chrome_options.add_argument('--allow-running-insecure-content')
self.chrome_options.add_argument('--ignore-certificate-errors')
self.chrome_capabilities = selenium.webdriver.common.desired_capabilities.DesiredCapabilities.CHROME.copy(
@@ -136,7 +146,8 @@
if headless:
self.chrome_options.add_argument('--headless')
self.chrome_options.add_argument('--disable-gpu')
- self.lock_file_path = '/usr/local/bin/chromedriver'
+ os.environ['WDM_LOG'] = str(logging.NOTSET)
+ self.executable_path = ChromeDriverManager().install()
self.timeout = timeout
def __enter__(self):
@@ -147,7 +158,7 @@
session. If an exception occurs while starting the browser, the lock
file is released.
"""
- self.lock_file = open(self.lock_file_path, 'r')
+ self.lock_file = open(self.executable_path, 'r')
start_time = time.time()
while time.time() < start_time + self.timeout:
try:
@@ -157,14 +168,11 @@
continue
try:
self.driver = selenium.webdriver.Chrome(
+ service=ChromeService(self.executable_path),
options=self.chrome_options,
desired_capabilities=self.chrome_capabilities)
- self.element_class = splinter.driver.webdriver.WebDriverElement
- self._cookie_manager = splinter.driver.webdriver.cookie_manager.CookieManager(
- self.driver)
- super(splinter.driver.webdriver.chrome.WebDriver,
- self).__init__(2)
- return super(BlockingBrowser, self).__enter__()
+ self.session_id = self.driver.session_id
+ return self
except:
fcntl.flock(self.lock_file, fcntl.LOCK_UN)
self.lock_file.close()
@@ -179,8 +187,7 @@
releases the lock file.
"""
try:
- super(BlockingBrowser, self).__exit__(exc_type, exc_value,
- traceback)
+ self.driver.quit()
except:
raise RuntimeError('Failed to quit browser. Releasing lock file.')
finally:
@@ -189,7 +196,7 @@
def restart(self):
"""Method to restart browser session without releasing lock file."""
- self.quit()
+ self.driver.quit()
self.__enter__()
def visit_persistent(self,
@@ -215,21 +222,25 @@
self.driver.set_page_load_timeout(page_load_timeout)
for idx in range(num_tries):
try:
- self.visit(url)
+ self.driver.get(url)
except:
self.restart()
- page_reached = self.url.split('/')[-1] == url.split('/')[-1]
- if check_for_element:
- time.sleep(BROWSER_WAIT_MED)
- element = self.find_by_id(check_for_element)
- if not element:
- page_reached = 0
+ page_reached = self.driver.current_url.split('/')[-1] == url.split(
+ '/')[-1]
if page_reached:
- break
+ if check_for_element:
+ time.sleep(BROWSER_WAIT_MED)
+ if self.is_element_visible(check_for_element):
+ break
+ else:
+ raise RuntimeError(
+ 'Page reached but expected element not found.')
+ else:
+ break
else:
try:
- self.visit(backup_url)
+ self.driver.get(backup_url)
except:
self.restart()
@@ -238,6 +249,125 @@
self.url))
raise RuntimeError('URL unreachable.')
+ def get_element_value(self, element_name):
+ """Function to look up and get webpage element value.
+
+ Args:
+ element_name: name of element to look up
+ Returns:
+ Value of element
+ """
+ #element = self.driver.find_element_by_name(element_name)
+ element = self.driver.find_element(By.NAME, element_name)
+ element_type = self.get_element_type(element_name)
+ if element_type == 'checkbox':
+ return element.is_selected()
+ elif element_type == 'radio':
+ items = self.driver.find_elements(By.NAME, element_name)
+ for item in items:
+ if item.is_selected():
+ return item.get_attribute('value')
+ else:
+ return element.get_attribute('value')
+
+ def get_element_type(self, element_name):
+ """Function to look up and get webpage element type.
+
+ Args:
+ element_name: name of element to look up
+ Returns:
+ Type of element
+ """
+ item = self.driver.find_element(By.NAME, element_name)
+ type = item.get_attribute('type')
+ return type
+
+ def is_element_enabled(self, element_name):
+ """Function to check if element is enabled/interactable.
+
+ Args:
+ element_name: name of element to look up
+ Returns:
+ Boolean indicating if element is interactable
+ """
+ item = self.driver.find_element(By.NAME, element_name)
+ return item.is_enabled()
+
+ def is_element_visible(self, element_name):
+ """Function to check if element is visible.
+
+ Args:
+ element_name: name of element to look up
+ Returns:
+ Boolean indicating if element is visible
+ """
+ item = self.driver.find_element(By.NAME, element_name)
+ return item.is_displayed()
+
+ def set_element_value(self, element_name, value, select_method='value'):
+ """Function to set webpage element value.
+
+ Args:
+ element_name: name of element to set
+ value: value of element
+ select_method: select method for dropdown lists (value/index/text)
+ """
+ element_type = self.get_element_type(element_name)
+ if element_type == 'text' or element_type == 'password':
+ item = self.driver.find_element(By.NAME, element_name)
+ item.clear()
+ item.send_keys(value)
+ elif element_type == 'checkbox':
+ item = self.driver.find_element(By.NAME, element_name)
+ if value != item.is_selected():
+ item.click()
+ elif element_type == 'radio':
+ items = self.driver.find_elements(By.NAME, element_name)
+ for item in items:
+ if item.get_attribute('value') == value:
+ item.click()
+ elif element_type == 'select-one':
+ select = Select(self.driver.find_element(By.NAME, element_name))
+ if select_method == 'value':
+ select.select_by_value(str(value))
+ elif select_method == 'text':
+ select.select_by_visible_text(value)
+ elif select_method == 'index':
+ select.select_by_index(value)
+ else:
+ raise RuntimeError(
+ '{} is not a valid select method.'.format(select_method))
+ else:
+ raise RuntimeError(
+ 'Element type {} not supported.'.format(element_type))
+
+ def click_button(self, button_name):
+ """Function to click button on webpage
+
+ Args:
+ button_name: name of button to click
+ """
+ button = self.driver.find_element(By.NAME, button_name)
+ if button.get_attribute('type') == 'submit':
+ button.click()
+ else:
+ raise RuntimeError('{} is not a button.'.format(button_name))
+
+ def accept_alert_if_present(self, wait_for_alert=1):
+ """Function to check for alert and accept if present
+
+ Args:
+ wait_for_alert: time (seconds) to wait for alert
+ """
+ try:
+ selenium.webdriver.support.ui.WebDriverWait(
+ self.driver,
+ wait_for_alert).until(expected_conditions.alert_is_present())
+ alert = self.driver.switch_to.alert
+ alert.accept()
+ except selenium.common.exceptions.TimeoutException:
+ pass
+
class WifiRetailAP(object):
"""Base class implementation for retail ap.
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/brcm_ref.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/brcm_ref.py
index 1b09533..c05ff40 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/brcm_ref.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/brcm_ref.py
@@ -1,5 +1,6 @@
import collections
import numpy
+import paramiko
import time
from acts_contrib.test_utils.wifi.wifi_retail_ap import WifiRetailAP
from acts_contrib.test_utils.wifi.wifi_retail_ap import BlockingBrowser
@@ -8,6 +9,8 @@
BROWSER_WAIT_MED = 3
BROWSER_WAIT_LONG = 10
BROWSER_WAIT_EXTRA_LONG = 60
+SSH_WAIT_SHORT = 0.1
+SSH_READ_BYTES = 600000
class BrcmRefAP(WifiRetailAP):
@@ -16,13 +19,45 @@
Since most of the class' implementation is shared with the R7000, this
class inherits from NetgearR7000AP and simply redefines config parameters
"""
+
def __init__(self, ap_settings):
super().__init__(ap_settings)
self.init_gui_data()
+ # Initialize SSH connection
+ self.init_ssh_connection()
# Read and update AP settings
self.read_ap_settings()
self.update_ap_settings(ap_settings)
+ def teardown(self):
+ """Function to perform destroy operations."""
+ if self.ap_settings.get('lock_ap', 0):
+ self._unlock_ap()
+ self.close_ssh_connection()
+
+ def init_ssh_connection(self):
+ self.ssh_client = paramiko.SSHClient()
+ self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+ self.ssh_client.connect(hostname=self.ap_settings['ip_address'],
+ username=self.ap_settings['admin_username'],
+ password=self.ap_settings['admin_password'],
+ look_for_keys=False,
+ allow_agent=False)
+
+ def close_ssh_connection(self):
+ self.ssh_client.close()
+
+ def run_ssh_cmd(self, command):
+ with self.ssh_client.invoke_shell() as shell:
+ shell.send('sh\n')
+ time.sleep(SSH_WAIT_SHORT)
+ shell.recv(SSH_READ_BYTES)
+ shell.send('{}\n'.format(command))
+ time.sleep(SSH_WAIT_SHORT)
+ response = shell.recv(SSH_READ_BYTES).decode('utf-8').splitlines()
+ response = [line for line in response[1:] if line != '# ']
+ return response
+
def init_gui_data(self):
self.config_page = ('{protocol}://{username}:{password}@'
'{ip_address}:{port}/info.html').format(
@@ -240,4 +275,146 @@
config_item.first.click()
time.sleep(BROWSER_WAIT_LONG)
browser.visit_persistent(self.config_page, BROWSER_WAIT_LONG,
- 10)
+ 10)
+
+ def set_power(self, interface, power):
+ """Function that sets interface transmit power.
+
+ Args:
+ interface: string containing interface identifier (2G_5G, 6G)
+ power: power level in dBm
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+
+ if power == 'auto':
+ response = self.run_ssh_cmd(
+ 'wl -i {} txpwr1 -1'.format(wl_interface))
+ else:
+ power_qdbm = int(power * 4)
+ response = self.run_ssh_cmd('wl -i {} txpwr1 -o -q {}'.format(
+ wl_interface, power_qdbm))
+
+ self.ap_settings[interface]['power'] = power_qdbm / 4
+
+ def get_power(self, interface):
+ """Function to get power used by AP
+
+ Args:
+ interface: interface to get rate on (2G_5G, 6G)
+ Returns:
+ power string returned by AP.
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+ return self.run_ssh_cmd('wl -i {} txpwr1'.format(wl_interface))
+
+ def set_rate(self,
+ interface,
+ mode=None,
+ num_streams=None,
+ rate='auto',
+ short_gi=0,
+ tx_expansion=0):
+ """Function that sets rate.
+
+ Args:
+ interface: string containing interface identifier (2G, 5G_1)
+ mode: string indicating the WiFi standard to use
+ num_streams: number of MIMO streams. used only for VHT
+ rate: data rate of MCS index to use
+ short_gi: boolean controlling the use of short guard interval
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+
+ if interface == '6G':
+ band_rate = '6g_rate'
+ elif self.ap_settings['2G_5G']['channel'] < 13:
+ band_rate = '2g_rate'
+ else:
+ band_rate = '5g_rate'
+
+ if rate == 'auto':
+ cmd_string = 'wl -i {} {} auto'.format(wl_interface, band_rate)
+ elif 'legacy' in mode.lower():
+ cmd_string = 'wl -i {} {} -r {} -x {}'.format(
+ wl_interface, band_rate, rate, tx_expansion)
+ elif 'ht' in mode.lower():
+ cmd_string = 'wl -i {} {} -h {} -x {}'.format(
+ wl_interface, band_rate, rate, tx_expansion)
+ if short_gi:
+ cmd_string = cmd_string + '--sgi'
+ elif 'vht' in mode.lower():
+ cmd_string = 'wl -i {} {} -v {}x{} -x {}'.format(
+ wl_interface, band_rate, rate, num_streams, tx_expansion)
+ if short_gi:
+ cmd_string = cmd_string + '--sgi'
+ elif 'he' in mode.lower():
+ cmd_string = 'wl -i {} {} -e {}x{} -l -x {}'.format(
+ wl_interface, band_rate, rate, num_streams, tx_expansion)
+ if short_gi:
+ cmd_string = cmd_string + '-i {}'.format(short_gi)
+
+ response = self.run_ssh_cmd(cmd_string)
+
+ self.ap_settings[interface]['mode'] = mode
+ self.ap_settings[interface]['num_streams'] = num_streams
+ self.ap_settings[interface]['rate'] = rate
+ self.ap_settings[interface]['short_gi'] = short_gi
+
+ def get_rate(self, interface):
+ """Function to get rate used by AP
+
+ Args:
+ interface: interface to get rate on (2G_5G, 6G)
+ Returns:
+ rate string returned by AP.
+ """
+
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+
+ if interface == '6G':
+ band_rate = '6g_rate'
+ elif self.ap_settings['2G_5G']['channel'] < 13:
+ band_rate = '2g_rate'
+ else:
+ band_rate = '5g_rate'
+ return self.run_ssh_cmd('wl -i {} {}'.format(wl_interface, band_rate))
+
+ def set_rts_enable(self, interface, enable):
+ """Function to enable or disable RTS/CTS
+
+ Args:
+ interface: interface to be configured (2G_5G, 6G)
+ enable: boolean controlling RTS/CTS behavior
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+ if enable:
+ self.run_ssh_cmd('wl -i {} ampdu_rts 1'.format(wl_interface))
+ self.run_ssh_cmd('wl -i {} rtsthresh 2437'.format(wl_interface))
+ else:
+ self.run_ssh_cmd('wl -i {} ampdu_rts 0'.format(wl_interface))
+ self.run_ssh_cmd('wl -i {} rtsthresh 15000'.format(wl_interface))
+
+ def set_tx_beamformer(self, interface, enable):
+ """Function to enable or disable transmit beamforming
+
+ Args:
+ interface: interface to be configured (2G_5G, 6G)
+ enable: boolean controlling beamformer behavior
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+
+ self.run_ssh_cmd('wl down')
+ self.run_ssh_cmd('wl -i {} txbf {}'.format(wl_interface, int(enable)))
+ self.run_ssh_cmd('wl up')
+
+ def get_sta_rssi(self, interface, sta_macaddr):
+ """Function to get RSSI from connected STA
+
+ Args:
+ interface: interface to be configured (2G_5G, 6G)
+ sta_macaddr: mac address of STA of interest
+ """
+ wl_interface = 'wl0' if interface == '6G' else 'wl1'
+
+ return self.run_ssh_cmd('wl -i {} phy_rssi_ant {}'.format(
+ wl_interface, sta_macaddr))
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/google_wifi.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/google_wifi.py
index a39c516..6c3230e 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/google_wifi.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/google_wifi.py
@@ -119,6 +119,10 @@
self.access_point = access_point.AccessPoint(init_settings)
self.configure_ap()
+ def teardown(self):
+ self.access_point.stop_all_aps()
+ super().teardown()
+
def read_ap_settings(self):
"""Function that reads current ap settings."""
return self.ap_settings.copy()
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7000.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7000.py
index ac118df..9c491a1 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7000.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7000.py
@@ -26,7 +26,11 @@
class NetgearR7000AP(WifiRetailAP):
"""Class that implements Netgear R7000 AP."""
+
def __init__(self, ap_settings):
+ self.log.warning(
+ 'This AP model is no longer maintained and must be updated/verified.'
+ )
super().__init__(ap_settings)
self.init_gui_data()
# Read and update AP settings
@@ -276,6 +280,7 @@
class NetgearR7000NAAP(NetgearR7000AP):
"""Class that implements Netgear R7000 NA AP."""
+
def init_gui_data(self):
"""Function to initialize data used while interacting with web GUI"""
super().init_gui_data()
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7500.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7500.py
index 06329b6..f554e0d 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7500.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_r7500.py
@@ -27,7 +27,11 @@
class NetgearR7500AP(WifiRetailAP):
"""Class that implements Netgear R7500 AP."""
+
def __init__(self, ap_settings):
+ self.log.warning(
+ 'This AP model is no longer maintained and must be updated/verified.'
+ )
super().__init__(ap_settings)
self.init_gui_data()
# Read and update AP settings
@@ -329,7 +333,8 @@
class NetgearR7500NAAP(NetgearR7500AP):
"""Class that implements Netgear R7500 NA AP."""
+
def init_gui_data(self):
"""Function to initialize data used while interacting with web GUI"""
super().init_gui_data()
- self.region_map['10'] = 'North America'
\ No newline at end of file
+ self.region_map['10'] = 'North America'
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax200.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax200.py
index d6c6fad..9363bbe 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax200.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax200.py
@@ -31,6 +31,7 @@
Since most of the class' implementation is shared with the R7000, this
class inherits from NetgearR7000AP and simply redefines config parameters
"""
+
def __init__(self, ap_settings):
super().__init__(ap_settings)
self.init_gui_data()
@@ -271,42 +272,38 @@
# Visit URL
browser.visit_persistent(self.config_page, BROWSER_WAIT_MED, 10)
- for key, value in self.config_page_fields.items():
- if 'status' in key:
+ for field_key, field_name in self.config_page_fields.items():
+ if 'status' in field_key:
browser.visit_persistent(self.config_page_advanced,
BROWSER_WAIT_MED, 10)
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][key[1]] = int(
- config_item.first.checked)
+ field_value = browser.get_element_value(field_name)
+ self.ap_settings[field_key[0]][field_key[1]] = int(
+ field_value)
browser.visit_persistent(self.config_page,
BROWSER_WAIT_MED, 10)
else:
- config_item = browser.find_by_name(value)
- if 'enable_ax' in key:
- self.ap_settings[key] = int(config_item.first.checked)
- elif 'bandwidth' in key:
- self.ap_settings[key[0]][key[1]] = self.bw_mode_values[
- self.ap_settings['enable_ax']][
- config_item.first.value]
- elif 'power' in key:
- self.ap_settings[key[0]][
- key[1]] = self.power_mode_values[
- config_item.first.value]
- elif 'region' in key:
+ field_value = browser.get_element_value(field_name)
+ if 'enable_ax' in field_key:
+ self.ap_settings[field_key] = int(field_value)
+ elif 'bandwidth' in field_key:
+ self.ap_settings[field_key[0]][
+ field_key[1]] = self.bw_mode_values[
+ self.ap_settings['enable_ax']][field_value]
+ elif 'power' in field_key:
+ self.ap_settings[field_key[0]][
+ field_key[1]] = self.power_mode_values[field_value]
+ elif 'region' in field_key:
self.ap_settings['region'] = self.region_map[
- config_item.first.value]
- elif 'security_type' in key:
- for item in config_item:
- if item.checked:
- self.ap_settings[key[0]][key[1]] = item.value
- elif 'channel' in key:
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][key[1]] = int(
- config_item.first.value)
+ field_value]
+ elif 'security_type' in field_key:
+ self.ap_settings[field_key[0]][
+ field_key[1]] = field_value
+ elif 'channel' in field_key:
+ self.ap_settings[field_key[0]][field_key[1]] = int(
+ field_value)
else:
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][
- key[1]] = config_item.first.value
+ self.ap_settings[field_key[0]][
+ field_key[1]] = field_value
return self.ap_settings.copy()
def configure_ap(self, **config_flags):
@@ -323,70 +320,67 @@
BROWSER_WAIT_MED, 10, self.config_page)
# Update region, and power/bandwidth for each network
- try:
- config_item = browser.find_by_name(
- self.config_page_fields['region']).first
- config_item.select_by_text(self.ap_settings['region'])
- except:
+ if browser.is_element_enabled(self.config_page_fields['region']):
+ browser.set_element_value(self.config_page_fields['region'],
+ self.ap_settings['region'],
+ select_method='text')
+ else:
self.log.warning('Cannot change region.')
- for key, value in self.config_page_fields.items():
- if 'enable_ax' in key:
- config_item = browser.find_by_name(value).first
- if self.ap_settings['enable_ax']:
- config_item.check()
- else:
- config_item.uncheck()
- if 'power' in key:
- config_item = browser.find_by_name(value).first
- config_item.select_by_text(
- self.ap_settings[key[0]][key[1]])
- elif 'bandwidth' in key:
- config_item = browser.find_by_name(value).first
+ for field_key, field_name in self.config_page_fields.items():
+ if 'enable_ax' in field_key:
+ browser.set_element_value(field_name,
+ self.ap_settings['enable_ax'])
+ if 'power' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]],
+ select_method='text')
+ elif 'bandwidth' in field_key:
try:
- config_item.select_by_text(self.bw_mode_text[key[0]][
- self.ap_settings[key[0]][key[1]]])
+ browser.set_element_value(
+ field_name,
+ self.bw_mode_text[field_key[0]][self.ap_settings[
+ field_key[0]][field_key[1]]],
+ select_method='text')
except AttributeError:
self.log.warning(
'Cannot select bandwidth. Keeping AP default.')
# Update security settings (passwords updated only if applicable)
- for key, value in self.config_page_fields.items():
- if 'security_type' in key:
- browser.choose(value, self.ap_settings[key[0]][key[1]])
- if 'WPA' in self.ap_settings[key[0]][key[1]]:
- config_item = browser.find_by_name(
- self.config_page_fields[(key[0],
- 'password')]).first
- config_item.fill(self.ap_settings[key[0]]['password'])
+ for field_key, field_name in self.config_page_fields.items():
+ if 'security_type' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
+ if 'WPA' in self.ap_settings[field_key[0]][field_key[1]]:
+ browser.set_element_value(
+ self.config_page_fields[(field_key[0],
+ 'password')],
+ self.ap_settings[field_key[0]]['password'])
- for key, value in self.config_page_fields.items():
- if 'ssid' in key:
- config_item = browser.find_by_name(value).first
- config_item.fill(self.ap_settings[key[0]][key[1]])
- elif 'channel' in key:
- config_item = browser.find_by_name(value).first
+ for field_key, field_name in self.config_page_fields.items():
+ if 'ssid' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
+ elif 'channel' in field_key:
+ config_item = browser.find_by_name(field_name).first
try:
- config_item.select(self.ap_settings[key[0]][key[1]])
- time.sleep(BROWSER_WAIT_SHORT)
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
except AttributeError:
self.log.warning(
'Cannot select channel. Keeping AP default.')
try:
for idx in range(0, 2):
- alert = browser.get_alert()
- alert.accept()
- time.sleep(BROWSER_WAIT_SHORT)
+ browser.accept_alert_if_present(BROWSER_WAIT_SHORT)
except:
pass
time.sleep(BROWSER_WAIT_SHORT)
- browser.find_by_name('Apply').first.click()
+ browser.click_button('Apply')
+ browser.accept_alert_if_present(BROWSER_WAIT_SHORT)
time.sleep(BROWSER_WAIT_SHORT)
- try:
- alert = browser.get_alert()
- alert.accept()
- time.sleep(BROWSER_WAIT_SHORT)
- except:
- time.sleep(BROWSER_WAIT_SHORT)
browser.visit_persistent(self.config_page, BROWSER_WAIT_EXTRA_LONG,
10)
@@ -400,16 +394,14 @@
BROWSER_WAIT_MED, 10)
# Turn radios on or off
- for key, value in self.config_page_fields.items():
- if 'status' in key:
- config_item = browser.find_by_name(value).first
- if self.ap_settings[key[0]][key[1]]:
- config_item.check()
- else:
- config_item.uncheck()
+ for field_key, field_name in self.config_page_fields.items():
+ if 'status' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
time.sleep(BROWSER_WAIT_SHORT)
- browser.find_by_name('Apply').first.click()
+ browser.click_button('Apply')
time.sleep(BROWSER_WAIT_EXTRA_LONG)
browser.visit_persistent(self.config_page, BROWSER_WAIT_EXTRA_LONG,
10)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_raxe500.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_raxe500.py
index 9dc60aa..c885e05 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_raxe500.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_raxe500.py
@@ -33,6 +33,7 @@
Since most of the class' implementation is shared with the R7000, this
class inherits from NetgearR7000AP and simply redefines config parameters
"""
+
def __init__(self, ap_settings):
super().__init__(ap_settings)
self.init_gui_data()
@@ -173,8 +174,6 @@
(('2G', 'bandwidth'), 'opmode'),
(('5G_1', 'bandwidth'), 'opmode_an'),
(('6G', 'bandwidth'), 'opmode_an_2'),
- (('2G', 'power'), 'enable_tpc'),
- (('5G_1', 'power'), 'enable_tpc_an'),
(('6G', 'security_type'), 'security_type_an_2'),
(('5G_1', 'security_type'), 'security_type_an'),
(('2G', 'security_type'), 'security_type'),
@@ -183,13 +182,6 @@
(('6G', 'password'), 'passphrase_an_2')
])
- self.power_mode_values = {
- '1': '100%',
- '2': '75%',
- '3': '50%',
- '4': '25%'
- }
-
def _set_channel_and_bandwidth(self,
network,
channel=None,
@@ -286,7 +278,9 @@
browser.visit_persistent(self.firmware_page, BROWSER_WAIT_MED, 10)
firmware_regex = re.compile(
r'Firmware Version[\s\S]+V(?P<version>[0-9._]+)')
- firmware_version = re.search(firmware_regex, browser.html)
+ #firmware_version = re.search(firmware_regex, browser.html)
+ firmware_version = re.search(firmware_regex,
+ browser.driver.page_source)
if firmware_version:
self.ap_settings['firmware_version'] = firmware_version.group(
'version')
@@ -300,42 +294,35 @@
# Visit URL
browser.visit_persistent(self.config_page, BROWSER_WAIT_MED, 10)
- for key, value in self.config_page_fields.items():
- if 'status' in key:
+ for field_key, field_name in self.config_page_fields.items():
+ if 'status' in field_key:
browser.visit_persistent(self.config_page_advanced,
BROWSER_WAIT_MED, 10)
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][key[1]] = int(
- config_item.first.checked)
+ field_value = browser.get_element_value(field_name)
+ self.ap_settings[field_key[0]][field_key[1]] = int(
+ field_value)
browser.visit_persistent(self.config_page,
BROWSER_WAIT_MED, 10)
else:
- config_item = browser.find_by_name(value)
- if 'enable_ax' in key:
- self.ap_settings[key] = int(config_item.first.checked)
- elif 'bandwidth' in key:
- self.ap_settings[key[0]][key[1]] = self.bw_mode_values[
- self.ap_settings['enable_ax']][
- config_item.first.value]
- elif 'power' in key:
- self.ap_settings[key[0]][
- key[1]] = self.power_mode_values[
- config_item.first.value]
- elif 'region' in key:
+ field_value = browser.get_element_value(field_name)
+ if 'enable_ax' in field_key:
+ self.ap_settings[field_key] = int(field_value)
+ elif 'bandwidth' in field_key:
+ self.ap_settings[field_key[0]][
+ field_key[1]] = self.bw_mode_values[
+ self.ap_settings['enable_ax']][field_value]
+ elif 'region' in field_key:
self.ap_settings['region'] = self.region_map[
- config_item.first.value]
- elif 'security_type' in key:
- for item in config_item:
- if item.checked:
- self.ap_settings[key[0]][key[1]] = item.value
- elif 'channel' in key:
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][key[1]] = int(
- config_item.first.value)
+ field_value]
+ elif 'security_type' in field_key:
+ self.ap_settings[field_key[0]][
+ field_key[1]] = field_value
+ elif 'channel' in field_key:
+ self.ap_settings[field_key[0]][field_key[1]] = int(
+ field_value)
else:
- config_item = browser.find_by_name(value)
- self.ap_settings[key[0]][
- key[1]] = config_item.first.value
+ self.ap_settings[field_key[0]][
+ field_key[1]] = field_value
return self.ap_settings.copy()
def configure_ap(self, **config_flags):
@@ -352,68 +339,58 @@
BROWSER_WAIT_MED, 10, self.config_page)
# Update region, and power/bandwidth for each network
- try:
- config_item = browser.find_by_name(
- self.config_page_fields['region']).first
- config_item.select_by_text(self.ap_settings['region'])
- except:
+ if browser.is_element_enabled(self.config_page_fields['region']):
+ browser.set_element_value(self.config_page_fields['region'],
+ self.ap_settings['region'],
+ select_method='text')
+ else:
self.log.warning('Cannot change region.')
- for key, value in self.config_page_fields.items():
- if 'enable_ax' in key:
- config_item = browser.find_by_name(value).first
- if self.ap_settings['enable_ax']:
- config_item.check()
- else:
- config_item.uncheck()
- if 'power' in key:
- config_item = browser.find_by_name(value).first
- config_item.select_by_text(
- self.ap_settings[key[0]][key[1]])
- elif 'bandwidth' in key:
- config_item = browser.find_by_name(value).first
+ for field_key, field_name in self.config_page_fields.items():
+ if 'enable_ax' in field_key:
+ browser.set_element_value(field_name,
+ self.ap_settings['enable_ax'])
+ elif 'bandwidth' in field_key:
try:
- config_item.select_by_text(self.bw_mode_text[key[0]][
- self.ap_settings[key[0]][key[1]]])
+ browser.set_element_value(
+ field_name,
+ self.bw_mode_text[field_key[0]][self.ap_settings[
+ field_key[0]][field_key[1]]],
+ select_method='text')
except AttributeError:
self.log.warning(
'Cannot select bandwidth. Keeping AP default.')
# Update security settings (passwords updated only if applicable)
- for key, value in self.config_page_fields.items():
- if 'security_type' in key:
- browser.choose(value, self.ap_settings[key[0]][key[1]])
- if 'WPA' in self.ap_settings[key[0]][key[1]]:
- config_item = browser.find_by_name(
- self.config_page_fields[(key[0],
- 'password')]).first
- config_item.fill(self.ap_settings[key[0]]['password'])
+ for field_key, field_name in self.config_page_fields.items():
+ if 'security_type' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
+ if 'WPA' in self.ap_settings[field_key[0]][field_key[1]]:
+ browser.set_element_value(
+ self.config_page_fields[(field_key[0],
+ 'password')],
+ self.ap_settings[field_key[0]]['password'])
- for key, value in self.config_page_fields.items():
- if 'ssid' in key:
- config_item = browser.find_by_name(value).first
- config_item.fill(self.ap_settings[key[0]][key[1]])
- elif 'channel' in key:
- config_item = browser.find_by_name(value).first
+ for field_key, field_name in self.config_page_fields.items():
+ if 'ssid' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
+ elif 'channel' in field_key:
try:
- config_item.select(self.ap_settings[key[0]][key[1]])
- time.sleep(BROWSER_WAIT_SHORT)
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
except AttributeError:
self.log.warning(
'Cannot select channel. Keeping AP default.')
- try:
- alert = browser.get_alert()
- alert.accept()
- except:
- pass
+ browser.accept_alert_if_present(BROWSER_WAIT_SHORT)
+
time.sleep(BROWSER_WAIT_SHORT)
- browser.find_by_name('Apply').first.click()
+ browser.click_button('Apply')
+ browser.accept_alert_if_present(BROWSER_WAIT_SHORT)
time.sleep(BROWSER_WAIT_SHORT)
- try:
- alert = browser.get_alert()
- alert.accept()
- time.sleep(BROWSER_WAIT_SHORT)
- except:
- time.sleep(BROWSER_WAIT_SHORT)
browser.visit_persistent(self.config_page, BROWSER_WAIT_EXTRA_LONG,
10)
@@ -427,16 +404,14 @@
BROWSER_WAIT_MED, 10)
# Turn radios on or off
- for key, value in self.config_page_fields.items():
- if 'status' in key:
- config_item = browser.find_by_name(value).first
- if self.ap_settings[key[0]][key[1]]:
- config_item.check()
- else:
- config_item.uncheck()
+ for field_key, field_name in self.config_page_fields.items():
+ if 'status' in field_key:
+ browser.set_element_value(
+ field_name,
+ self.ap_settings[field_key[0]][field_key[1]])
time.sleep(BROWSER_WAIT_SHORT)
- browser.find_by_name('Apply').first.click()
+ browser.click_button('Apply')
time.sleep(BROWSER_WAIT_EXTRA_LONG)
browser.visit_persistent(self.config_page, BROWSER_WAIT_EXTRA_LONG,
10)
diff --git a/acts_tests/tests/OWNERS b/acts_tests/tests/OWNERS
index 189ff2e..eb3d0c0 100644
--- a/acts_tests/tests/OWNERS
+++ b/acts_tests/tests/OWNERS
@@ -18,6 +18,8 @@
# Pixel GTW
jasonkmlu@google.com
hongscott@google.com
+diegowchung@google.com
+kuoyuanchiang@google.com
markusliu@google.com
jerrypcchen@google.com
martschneider@google.com
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py b/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
index c775dd7..3104452 100644
--- a/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
@@ -21,20 +21,26 @@
class BtA2dpRangeTest(A2dpBaseTest):
+
def __init__(self, configs):
super().__init__(configs)
req_params = ['attenuation_vector', 'codecs']
+ opt_params = ['gain_mismatch', 'dual_chain']
#'attenuation_vector' is a dict containing: start, stop and step of
#attenuation changes
#'codecs' is a list containing all codecs required in the tests
self.unpack_userparams(req_params)
+ self.unpack_userparams(opt_params, dual_chain=None, gain_mismatch=None)
+
+ def setup_generated_tests(self):
for codec_config in self.codecs:
- self.generate_test_case(codec_config)
+ arg_set = [(codec_config, )]
+ self.generate_tests(test_logic=self.BtA2dp_test_logic,
+ name_func=self.create_test_name,
+ arg_sets=arg_set)
def setup_class(self):
super().setup_class()
- opt_params = ['gain_mismatch', 'dual_chain']
- self.unpack_userparams(opt_params, dual_chain=None, gain_mismatch=None)
# Enable BQR on all android devices
btutils.enable_bqr(self.android_devices)
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
@@ -49,14 +55,14 @@
self.atten_c0.set_atten(INIT_ATTEN)
self.atten_c1.set_atten(INIT_ATTEN)
- def generate_test_case(self, codec_config):
- def test_case_fn():
- self.run_a2dp_to_max_range(codec_config)
+ def BtA2dp_test_logic(self, codec_config):
+ self.run_a2dp_to_max_range(codec_config)
+ def create_test_name(self, arg_set):
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
- test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmimatch_{}dB'.format(
- codec_config['codec_type'], self.gain_mismatch)
+ test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmismatch_{}dB'.format(
+ arg_set['codec_type'], self.gain_mismatch)
else:
test_case_name = 'test_bt_a2dp_range_codec_{}'.format(
- codec_config['codec_type'])
- setattr(self, test_case_name, test_case_fn)
+ arg_set['codec_type'])
+ return test_case_name
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py
index 5fe9503..16fedcd 100644
--- a/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py
@@ -57,35 +57,39 @@
test_bt_a2dp_range_codec_SBC_adv_mode_low_latency_adv_tx_power_low
test_bt_a2dp_range_codec_SBC_adv_mode_low_latency_adv_tx_power_medium
test_bt_a2dp_range_codec_SBC_adv_mode_low_latency_adv_tx_power_high
-
"""
+
def __init__(self, configs):
super().__init__(configs)
req_params = ['attenuation_vector', 'codecs']
- #'attenuation_vector' is a dict containing: start, stop and step of
- #attenuation changes
+ opt_params = ['gain_mismatch', 'dual_chain']
+ #'attenuation_vector' is a dict containing: start, stop and step of attenuation changes
#'codecs' is a list containing all codecs required in the tests
+ #'gain_mismatch' is an offset value between the BT two chains
+ #'dual_chain' set to 1 enable sweeping attenuation for BT two chains
self.unpack_userparams(req_params)
+ self.unpack_userparams(opt_params, dual_chian=None, gain_mismatch=None)
+
+ def setup_generated_tests(self):
for codec_config in self.codecs:
- # Loop all advertise modes and power levels
for adv_mode in ble_advertise_settings_modes.items():
- for adv_power_level in ble_advertise_settings_tx_powers.items(
- ):
- self.generate_test_case(codec_config, adv_mode,
- adv_power_level)
+ for adv_power_level in ble_advertise_settings_tx_powers.items():
+ arg_set = [(codec_config, adv_mode, adv_power_level)]
+ self.generate_tests(
+ test_logic=self.BtA2dp_with_ble_adv_test_logic,
+ name_func=self.create_test_name,
+ arg_sets=arg_set)
def setup_class(self):
super().setup_class()
- opt_params = ['gain_mismatch', 'dual_chain']
- self.unpack_userparams(opt_params, dual_chain=None, gain_mismatch=None)
- return setup_multiple_devices_for_bt_test(self.android_devices)
- # Enable BQR on all android devices
+ #Enable BQR on all android devices
btutils.enable_bqr(self.android_devices)
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
self.atten_c0 = self.attenuators[0]
self.atten_c1 = self.attenuators[1]
self.atten_c0.set_atten(INIT_ATTEN)
self.atten_c1.set_atten(INIT_ATTEN)
+ return setup_multiple_devices_for_bt_test(self.android_devices)
def teardown_class(self):
super().teardown_class()
@@ -93,20 +97,22 @@
self.atten_c0.set_atten(INIT_ATTEN)
self.atten_c1.set_atten(INIT_ATTEN)
- def generate_test_case(self, codec_config, adv_mode, adv_power_level):
- def test_case_fn():
- adv_callback = self.start_ble_adv(adv_mode[1], adv_power_level[1])
- self.run_a2dp_to_max_range(codec_config)
- self.dut.droid.bleStopBleAdvertising(adv_callback)
- self.log.info("Advertisement stopped Successfully")
+ def BtA2dp_with_ble_adv_test_logic(self, codec_config, adv_mode,
+ adv_power_level):
+ adv_callback = self.start_ble_adv(adv_mode[1], adv_power_level[1])
+ self.run_a2dp_to_max_range(codec_config)
+ self.dut.droid.bleStopBleAdvertising(adv_callback)
+ self.log.info("Advertisement stopped Successfully")
+ def create_test_name(self, codec_config, adv_mode, adv_power_level):
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
- test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmimatch_{}dB'.format(
- codec_config['codec_type'], self.gain_mismatch)
+ test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmismatch_{}dB_adv_mode_{}_adv_tx_power_{}'.format(
+ codec_config['codec_type'], self.gain_mismatch, adv_mode[0],
+ adv_power_level[0])
else:
test_case_name = 'test_bt_a2dp_range_codec_{}_adv_mode_{}_adv_tx_power_{}'.format(
codec_config['codec_type'], adv_mode[0], adv_power_level[0])
- setattr(self, test_case_name, test_case_fn)
+ return test_case_name
def start_ble_adv(self, adv_mode, adv_power_level):
"""Function to start an LE advertisement
@@ -140,3 +146,4 @@
raise BtTestUtilsError(
"Advertiser did not start successfully {}".format(err))
return advertise_callback
+
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleScanTest.py b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleScanTest.py
index 6020c4a..4cd2dd7 100644
--- a/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleScanTest.py
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleScanTest.py
@@ -25,32 +25,50 @@
class BtA2dpRangeWithBleScanTest(A2dpBaseTest):
- default_timeout = 10
+ """User can generate test case with below format.
+ test_bt_a2dp_range_codec_"Codec"_with_BLE_scan_"Scan Mode"
+
+ Below are the list of test cases:
+ test_bt_a2dp_range_codec_AAC_with_BLE_scan_balanced
+ test_bt_a2dp_range_codec_AAC_with_BLE_scan_low_latency
+ test_bt_a2dp_range_codec_AAC_with_BLE_scan_low_power
+ test_bt_a2dp_range_codec_AAC_with_BLE_scan_opportunistic
+ test_bt_a2dp_range_codec_SBC_with_BLE_scan_balanced
+ test_bt_a2dp_range_codec_SBC_with_BLE_scan_low_latency
+ test_bt_a2dp_range_codec_SBC_with_BLE_scan_low_power
+ test_bt_a2dp_range_codec_SBC_with_BLE_scan_opportunistic
+ """
def __init__(self, configs):
super().__init__(configs)
req_params = ['attenuation_vector', 'codecs']
- #'attenuation_vector' is a dict containing: start, stop and step of
- #attenuation changes
+ opt_params = ['gain_mismatch', 'dual_chain']
+ #'attenuation_vector' is a dict containing: start, stop and step of attenuation changes
#'codecs' is a list containing all codecs required in the tests
+ #'gain_mismatch' is an offset value between the BT two chains
+ #'dual_chain' set to 1 enable sweeping attenuation for BT two chains
self.unpack_userparams(req_params)
+ self.unpack_userparams(opt_params, dual_chian=None, gain_mismatch=None)
+
+ def setup_generated_tests(self):
for codec_config in self.codecs:
- # Loop all BLE Scan modes
for scan_mode in ble_scan_settings_modes.items():
- self.generate_test_case(codec_config, scan_mode)
+ arg_set = [(codec_config, scan_mode)]
+ self.generate_tests(
+ test_logic=self.BtA2dp_with_ble_scan_test_logic,
+ name_func=self.create_test_name,
+ arg_sets=arg_set)
def setup_class(self):
super().setup_class()
- opt_params = ['gain_mismatch', 'dual_chain']
- self.unpack_userparams(opt_params, dual_chain=None, gain_mismatch=None)
- return setup_multiple_devices_for_bt_test(self.android_devices)
- # Enable BQR on all android devices
+ #Enable BQR on all android devices
btutils.enable_bqr(self.android_devices)
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
self.atten_c0 = self.attenuators[0]
self.atten_c1 = self.attenuators[1]
self.atten_c0.set_atten(INIT_ATTEN)
self.atten_c1.set_atten(INIT_ATTEN)
+ return setup_multiple_devices_for_bt_test(self.android_devices)
def teardown_class(self):
super().teardown_class()
@@ -58,31 +76,20 @@
self.atten_c0.set_atten(INIT_ATTEN)
self.atten_c1.set_atten(INIT_ATTEN)
- def generate_test_case(self, codec_config, scan_mode):
- """ Below are the list of test case's user can choose to run.
- Test case list:
- "test_bt_a2dp_range_codec_AAC_with_BLE_scan_balanced"
- "test_bt_a2dp_range_codec_AAC_with_BLE_scan_low_latency"
- "test_bt_a2dp_range_codec_AAC_with_BLE_scan_low_power"
- "test_bt_a2dp_range_codec_AAC_with_BLE_scan_opportunistic"
- "test_bt_a2dp_range_codec_SBC_with_BLE_scan_balanced"
- "test_bt_a2dp_range_codec_SBC_with_BLE_scan_low_latency"
- "test_bt_a2dp_range_codec_SBC_with_BLE_scan_low_power"
- "test_bt_a2dp_range_codec_SBC_with_BLE_scan_opportunistic"
- """
- def test_case_fn():
- scan_callback = self.start_ble_scan(scan_mode[1])
- self.run_a2dp_to_max_range(codec_config)
- self.dut.droid.bleStopBleScan(scan_callback)
- self.log.info("BLE Scan stopped succssfully")
+ def BtA2dp_with_ble_scan_test_logic(self, codec_config, scan_mode):
+ scan_callback = self.start_ble_scan(scan_mode[1])
+ self.run_a2dp_to_max_range(codec_config)
+ self.dut.droid.bleStopBleScan(scan_callback)
+ self.log.info("BLE Scan stopped successfully")
+ def create_test_name(self, codec_config, scan_mode):
if hasattr(self, 'dual_chain') and self.dual_chain == 1:
- test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmimatch_{}dB'.format(
- codec_config['codec_type'], self.gain_mismatch)
+ test_case_name = 'test_dual_bt_a2dp_range_codec_{}_gainmismatch_{}dB_with_BLE_scan_{}'.format(
+ codec_config['codec_type'], self.gain_mismatch, scan_mode[0])
else:
test_case_name = 'test_bt_a2dp_range_codec_{}_with_BLE_scan_{}'.format(
codec_config['codec_type'], scan_mode[0])
- setattr(self, test_case_name, test_case_fn)
+ return test_case_name
def start_ble_scan(self, scan_mode):
""" This function will start Ble Scan with different scan mode.
@@ -99,5 +106,6 @@
self.dut.droid)
self.dut.droid.bleStartBleScan(filter_list, scan_settings,
scan_callback)
- self.log.info("BLE Scanning started succssfully")
+ self.log.info("BLE Scanning started successfully")
return scan_callback
+
diff --git a/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py b/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
index 99218b0..6ec585d 100644
--- a/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
+++ b/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
@@ -29,49 +29,39 @@
class BtInterferenceStaticTest(BtInterferenceBaseTest):
+
def __init__(self, configs):
super().__init__(configs)
self.bt_attenuation_range = range(self.attenuation_vector['start'],
self.attenuation_vector['stop'] + 1,
self.attenuation_vector['step'])
-
self.iperf_duration = self.audio_params['duration'] + TIME_OVERHEAD
- for level in list(
- self.static_wifi_interference['interference_level'].keys()):
- for channels in self.static_wifi_interference['channels']:
- self.generate_test_case(
- self.static_wifi_interference['interference_level'][level],
- channels)
-
test_metrics = [
- 'wifi_chan1_rssi', 'wifi_chan6_rssi', 'wifi_chan11_rssi',
- 'bt_range'
+ 'wifi_chan1_rssi', 'wifi_chan6_rssi', 'wifi_chan11_rssi', 'bt_range'
]
for metric in test_metrics:
setattr(self, '{}_metric'.format(metric),
BlackboxMetricLogger.for_test_case(metric_name=metric))
- def generate_test_case(self, interference_level, channels):
- """Function to generate test cases with different parameters.
+ def setup_generated_tests(self):
+ for level in list(
+ self.static_wifi_interference['interference_level'].values()):
+ for channels in self.static_wifi_interference['channels']:
+ arg_set = [(level, channels)]
+ self.generate_tests(
+ test_logic=self.bt_range_with_static_wifi_interference,
+ name_func=self.create_test_name,
+ arg_sets=arg_set)
- Args:
- interference_level: wifi interference signal level
- channels: wifi interference channel or channel combination
- """
- def test_case_fn():
- self.bt_range_with_static_wifi_interference(
- interference_level, channels)
-
+ def create_test_name(self, level, channels):
str_channel_test = ''
for i in channels:
- str_channel_test = str_channel_test + str(i) + '_'
+ str_channel_test = str_channel_test + str(i) + "_"
test_case_name = ('test_bt_range_with_static_interference_level_{}_'
- 'channel_{}'.format(interference_level,
- str_channel_test))
- setattr(self, test_case_name, test_case_fn)
+ 'channel_{}'.format(level, str_channel_test))
+ return test_case_name
- def bt_range_with_static_wifi_interference(self, interference_level,
- channels):
+ def bt_range_with_static_wifi_interference(self, level, channels):
"""Test function to measure bt range under interference.
Args:
@@ -79,8 +69,7 @@
channels: wifi interference channels
"""
#setup wifi interference by setting the correct attenuator
- inject_static_wifi_interference(self.wifi_int_pairs,
- interference_level, channels)
+ inject_static_wifi_interference(self.wifi_int_pairs, level, channels)
# Read interference RSSI
self.get_interference_rssi()
self.wifi_chan1_rssi_metric.metric_value = self.interference_rssi[0][
@@ -113,8 +102,7 @@
self.iperf_duration, obj.iperf_server.port)
tag = 'chan_{}'.format(obj.channel)
proc_iperf = Process(target=obj.iperf_client.start,
- args=(obj.server_address, iperf_args,
- tag))
+ args=(obj.server_address, iperf_args, tag))
procs_iperf.append(proc_iperf)
#play a2dp streaming and run thdn analysis
@@ -140,8 +128,8 @@
self.log.info('THDN results are {} at {} dB attenuation'.format(
thdns, atten))
self.log.info('DUT rssi {} dBm, master tx power level {}, '
- 'RemoteDevice rssi {} dBm'.format(rssi_primary, pwl_primary,
- rssi_secondary))
+ 'RemoteDevice rssi {} dBm'.format(
+ rssi_primary, pwl_primary, rssi_secondary))
for thdn in thdns:
if thdn >= self.audio_params['thdn_threshold']:
self.log.info('Under the WiFi interference condition: '
@@ -154,3 +142,4 @@
raise TestPass(
'Max range for this test is {}, with BT master RSSI at'
' {} dBm'.format(atten, rssi_primary))
+
diff --git a/acts_tests/tests/google/bt/performance/BtRfcommThroughputRangeTest.py b/acts_tests/tests/google/bt/performance/BtRfcommThroughputRangeTest.py
new file mode 100644
index 0000000..342f2f0
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/BtRfcommThroughputRangeTest.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+#
+# Copyright 2017 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 os
+import logging
+import pandas as pd
+import time
+import acts_contrib.test_utils.bt.bt_test_utils as btutils
+from acts_contrib.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest
+from acts_contrib.test_utils.bt.ble_performance_test_utils import plot_graph
+from acts_contrib.test_utils.power.PowerBTBaseTest import ramp_attenuation
+from acts_contrib.test_utils.bt.bt_test_utils import setup_multiple_devices_for_bt_test
+from acts_contrib.test_utils.bt.bt_test_utils import orchestrate_rfcomm_connection
+from acts.signals import TestPass
+from acts import utils
+from acts_contrib.test_utils.bt.bt_test_utils import write_read_verify_data
+
+INIT_ATTEN = 0
+WRITE_ITERATIONS = 500
+
+
+class BtRfcommThroughputRangeTest(BluetoothBaseTest):
+ def __init__(self, configs):
+ super().__init__(configs)
+ req_params = ['attenuation_vector', 'system_path_loss']
+ #'attenuation_vector' is a dict containing: start, stop and step of
+ #attenuation changes
+ self.unpack_userparams(req_params)
+
+ def setup_class(self):
+ super().setup_class()
+ self.dut = self.android_devices[0]
+ self.remote_device = self.android_devices[1]
+ btutils.enable_bqr(self.android_devices)
+ if hasattr(self, 'attenuators'):
+ self.attenuator = self.attenuators[0]
+ self.attenuator.set_atten(INIT_ATTEN)
+ self.attenuation_range = range(self.attenuation_vector['start'],
+ self.attenuation_vector['stop'] + 1,
+ self.attenuation_vector['step'])
+ self.log_path = os.path.join(logging.log_path, 'results')
+ os.makedirs(self.log_path, exist_ok=True)
+ return setup_multiple_devices_for_bt_test(self.android_devices)
+
+ def teardown_test(self):
+ self.dut.droid.bluetoothSocketConnStop()
+ self.remote_device.droid.bluetoothSocketConnStop()
+ if hasattr(self, 'attenuator'):
+ self.attenuator.set_atten(INIT_ATTEN)
+
+ def test_rfcomm_throughput_range(self):
+ data_points = []
+ message = "x" * 990
+ self.file_output = os.path.join(
+ self.log_path, '{}.csv'.format(self.current_test_name))
+ if not orchestrate_rfcomm_connection(self.dut, self.remote_device):
+ return False
+ self.log.info("RFCOMM Connection established")
+ for atten in self.attenuation_range:
+ ramp_attenuation(self.attenuator, atten)
+ self.log.info('Set attenuation to %d dB', atten)
+ process_data_dict = btutils.get_bt_metric(self.dut)
+ rssi_primary = process_data_dict.get('rssi')
+ pwlv_primary = process_data_dict.get('pwlv')
+ rssi_primary = rssi_primary.get(self.dut.serial)
+ pwlv_primary = pwlv_primary.get(self.dut.serial)
+ self.log.info("DUT RSSI:{} and PwLv:{} with attenuation:{}".format(
+ rssi_primary, pwlv_primary, atten))
+ if type(rssi_primary) != str:
+ data_rate = self.write_read_verify_rfcommdata(
+ self.dut, self.remote_device, message)
+ data_point = {
+ 'attenuation_db': atten,
+ 'Dut_RSSI': rssi_primary,
+ 'DUT_PwLv': pwlv_primary,
+ 'Pathloss': atten + self.system_path_loss,
+ 'RfcommThroughput': data_rate
+ }
+ data_points.append(data_point)
+ df = pd.DataFrame(data_points)
+ # bokeh data for generating BokehFigure
+ bokeh_data = {
+ 'x_label': 'Pathloss (dBm)',
+ 'primary_y_label': 'RSSI (dBm)',
+ 'log_path': self.log_path,
+ 'current_test_name': self.current_test_name
+ }
+ # plot_data for adding line to existing BokehFigure
+ plot_data = {
+ 'line_one': {
+ 'x_column': 'Pathloss',
+ 'y_column': 'Dut_RSSI',
+ 'legend': 'DUT RSSI (dBm)',
+ 'marker': 'circle_x',
+ 'y_axis': 'default'
+ },
+ 'line_two': {
+ 'x_column': 'Pathloss',
+ 'y_column': 'RfcommThroughput',
+ 'legend': 'RFCOMM Throughput (bits/sec)',
+ 'marker': 'hex',
+ 'y_axis': 'secondary'
+ }
+ }
+ else:
+ df.to_csv(self.file_output, index=False)
+ plot_graph(df,
+ plot_data,
+ bokeh_data,
+ secondary_y_label='RFCOMM Throughput (bits/sec)')
+ raise TestPass("Reached RFCOMM Max Range,RFCOMM disconnected.")
+ # Save Data points to csv
+ df.to_csv(self.file_output, index=False)
+ # Plot graph
+ plot_graph(df,
+ plot_data,
+ bokeh_data,
+ secondary_y_label='RFCOMM Throughput (bits/sec)')
+ self.dut.droid.bluetoothRfcommStop()
+ self.remote_device.droid.bluetoothRfcommStop()
+ return True
+
+ def write_read_verify_rfcommdata(self, dut, remote_device, msg):
+ """Verify that the client wrote data to the remote Android device correctly.
+
+ Args:
+ dut: the Android device to perform the write.
+ remote_device: the Android device to read the data written.
+ msg: the message to write.
+ Returns:
+ True if the data written matches the data read, false if not.
+ """
+ start_write_time = time.perf_counter()
+ for n in range(WRITE_ITERATIONS):
+ try:
+ dut.droid.bluetoothSocketConnWrite(msg)
+ except Exception as err:
+ dut.log.error("Failed to write data: {}".format(err))
+ return False
+ try:
+ read_msg = remote_device.droid.bluetoothSocketConnRead()
+ except Exception as err:
+ remote_device.log.error("Failed to read data: {}".format(err))
+ return False
+ if msg != read_msg:
+ self.log.error("Mismatch! Read: {}, Expected: {}".format(
+ read_msg, msg))
+ return False
+ end_read_time = time.perf_counter()
+ total_num_bytes = 990 * WRITE_ITERATIONS
+ test_time = (end_read_time - start_write_time)
+ if (test_time == 0):
+ dut.log.error("Buffer transmits cannot take zero time")
+ return 0
+ data_rate = (1.000 * total_num_bytes) / test_time
+ self.log.info(
+ "Calculated using total write and read times: total_num_bytes={}, "
+ "test_time={}, data rate={:08.0f} bytes/sec, {:08.0f} bits/sec".
+ format(total_num_bytes, test_time, data_rate, (data_rate * 8)))
+ data_rate = data_rate * 8
+ return data_rate
diff --git a/acts_tests/tests/google/cellular/performance/Cellular5GFR2SensitivityTest.py b/acts_tests/tests/google/cellular/performance/Cellular5GFR2SensitivityTest.py
new file mode 100644
index 0000000..f3e49b8
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/Cellular5GFR2SensitivityTest.py
@@ -0,0 +1,235 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import itertools
+import json
+import numpy
+import os
+from functools import partial
+from acts import asserts
+from acts import context
+from acts import base_test
+from acts import utils
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts.controllers.utils_lib import ssh
+from acts_contrib.test_utils.cellular.keysight_5g_testapp import Keysight5GTestApp
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure import BokehFigure
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from Cellular5GFR2ThroughputTest import Cellular5GFR2ThroughputTest
+
+
+class Cellular5GFR2SensitivityTest(Cellular5GFR2ThroughputTest):
+ """Class to test cellular throughput
+
+ This class implements cellular throughput tests on a lab/callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+
+ def setup_class(self):
+ """Initializes common test hardware and parameters.
+
+ This function initializes hardwares and compiles parameters that are
+ common to all tests in this class.
+ """
+ self.dut = self.android_devices[-1]
+ self.testclass_params = self.user_params['sensitivity_test_params']
+ self.keysight_test_app = Keysight5GTestApp(
+ self.user_params['Keysight5GTestApp'])
+ self.testclass_results = collections.OrderedDict()
+ self.iperf_server = self.iperf_servers[0]
+ self.iperf_client = self.iperf_clients[0]
+ self.remote_server = ssh.connection.SshConnection(
+ ssh.settings.from_config(
+ self.user_params['RemoteServer']['ssh_config']))
+ if self.testclass_params.get('reload_scpi', 1):
+ self.keysight_test_app.import_scpi_file(
+ self.testclass_params['scpi_file'])
+ # Configure test retries
+ self.user_params['retry_tests'] = [self.__class__.__name__]
+
+ # Turn Airplane mode on
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+
+ def process_testcase_results(self):
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_results = self.testclass_results[self.current_test_name]
+ cell_power_list = [
+ result['cell_power'] for result in testcase_results['results']
+ ]
+ dl_bler_list = [
+ result['bler_result']['total']['DL']['nack_ratio']
+ for result in testcase_results['results']
+ ]
+ bler_above_threshold = [
+ x > self.testclass_params['bler_threshold'] for x in dl_bler_list
+ ]
+ for idx in range(len(bler_above_threshold)):
+ if all(bler_above_threshold[idx:]):
+ sensitivity_index = max(idx, 1) - 1
+ cell_power_at_sensitivity = cell_power_list[sensitivity_index]
+ break
+ else:
+ sensitivity_index = -1
+ cell_power_at_sensitivity = float('nan')
+ if min(dl_bler_list) < 0.05:
+ testcase_results['sensitivity'] = cell_power_at_sensitivity
+ else:
+ testcase_results['sensitivity'] = float('nan')
+
+ testcase_results['cell_power_list'] = cell_power_list
+ testcase_results['dl_bler_list'] = dl_bler_list
+
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_results),
+ results_file,
+ indent=4)
+
+ result_string = ('DL {}CC MCS {} Sensitivity = {}dBm.'.format(
+ testcase_results['testcase_params']['num_dl_cells'],
+ testcase_results['testcase_params']['dl_mcs'],
+ testcase_results['sensitivity']))
+ if min(dl_bler_list) < 0.05:
+ self.log.info('Test Passed. {}'.format(result_string))
+ else:
+ self.log.info('Result unreliable. {}'.format(result_string))
+
+ def process_testclass_results(self):
+ Cellular5GFR2ThroughputTest.process_testclass_results(self)
+
+ plots = collections.OrderedDict()
+ id_fields = ['band', 'num_dl_cells']
+ for testcase, testcase_data in self.testclass_results.items():
+ testcase_params = testcase_data['testcase_params']
+ plot_id = cputils.extract_test_id(testcase_params, id_fields)
+ plot_id = tuple(plot_id.items())
+ if plot_id not in plots:
+ plots[plot_id] = BokehFigure(title='{} {}CC'.format(
+ testcase_params['band'], testcase_params['num_dl_cells']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='BLER (%)')
+ plots[plot_id].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['dl_bler_list'],
+ 'Channel {}, MCS {}'.format(testcase_params['channel'],
+ testcase_params['dl_mcs']))
+ figure_list = []
+ for plot_id, plot in plots.items():
+ plot.generate_figure()
+ figure_list.append(plot)
+ output_file_path = os.path.join(self.log_path, 'results.html')
+ BokehFigure.save_figures(figure_list, output_file_path)
+
+ def generate_test_cases(self, bands, channels, mcs_pair_list,
+ num_dl_cells_list, num_ul_cells_list, **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+
+ for band, channel, num_ul_cells, num_dl_cells, mcs_pair in itertools.product(
+ bands, channels, num_ul_cells_list, num_dl_cells_list,
+ mcs_pair_list):
+ if num_ul_cells > num_dl_cells:
+ continue
+ test_name = 'test_nr_sensitivity_{}_{}_DL_{}CC_mcs{}'.format(
+ band, channel, num_dl_cells, mcs_pair[0])
+ test_params = collections.OrderedDict(
+ band=band,
+ channel=channel,
+ dl_mcs=mcs_pair[0],
+ ul_mcs=mcs_pair[1],
+ num_dl_cells=num_dl_cells,
+ num_ul_cells=num_ul_cells,
+ dl_cell_list=list(range(1, num_dl_cells + 1)),
+ ul_cell_list=list(range(1, num_ul_cells + 1)),
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_nr_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
+class Cellular5GFR2_AllBands_SensitivityTest(Cellular5GFR2SensitivityTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(16, 4), (27, 4)],
+ list(range(1, 9)), [1],
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0)
+
+
+class Cellular5GFR2_FrequencySweep_SensitivityTest(Cellular5GFR2SensitivityTest
+ ):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ frequency_sweep_params = self.user_params['sensitivity_test_params'][
+ 'frequency_sweep']
+ self.tests = self.generate_test_cases(frequency_sweep_params,
+ [(16, 4), (27, 4)],
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0)
+
+ def generate_test_cases(self, dl_frequency_sweep_params, mcs_pair_list,
+ **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = ['test_load_scpi']
+
+ for band, band_config in dl_frequency_sweep_params.items():
+ for num_dl_cells_str, sweep_config in band_config.items():
+ num_dl_cells = int(num_dl_cells_str[0])
+ num_ul_cells = 1
+ freq_vector = numpy.arange(sweep_config[0], sweep_config[1],
+ sweep_config[2])
+ for freq in freq_vector:
+ for mcs_pair in mcs_pair_list:
+ test_name = 'test_nr_sensitivity_{}_{}_DL_{}CC_mcs{}'.format(
+ band, freq, num_dl_cells, mcs_pair[0])
+ test_params = collections.OrderedDict(
+ band=band,
+ channel=freq,
+ dl_mcs=mcs_pair[0],
+ ul_mcs=mcs_pair[1],
+ num_dl_cells=num_dl_cells,
+ num_ul_cells=num_ul_cells,
+ dl_cell_list=list(range(1, num_dl_cells + 1)),
+ ul_cell_list=list(range(1, num_ul_cells + 1)),
+ **kwargs)
+ setattr(
+ self, test_name,
+ partial(self._test_nr_throughput_bler,
+ test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/Cellular5GFR2ThroughputTest.py b/acts_tests/tests/google/cellular/performance/Cellular5GFR2ThroughputTest.py
new file mode 100644
index 0000000..9e848a3
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/Cellular5GFR2ThroughputTest.py
@@ -0,0 +1,664 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import json
+import numpy
+import os
+import time
+from acts import asserts
+from acts import context
+from acts import base_test
+from acts import utils
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts.controllers.utils_lib import ssh
+from acts.controllers import iperf_server as ipf
+from acts_contrib.test_utils.cellular.keysight_5g_testapp import Keysight5GTestApp
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+
+from functools import partial
+
+LONG_SLEEP = 10
+MEDIUM_SLEEP = 2
+IPERF_TIMEOUT = 10
+SHORT_SLEEP = 1
+SUBFRAME_LENGTH = 0.001
+STOP_COUNTER_LIMIT = 3
+
+
+class Cellular5GFR2ThroughputTest(base_test.BaseTestClass):
+ """Class to test cellular throughput
+
+ This class implements cellular throughput tests on a lab/callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+
+ def setup_class(self):
+ """Initializes common test hardware and parameters.
+
+ This function initializes hardwares and compiles parameters that are
+ common to all tests in this class.
+ """
+ self.dut = self.android_devices[-1]
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.keysight_test_app = Keysight5GTestApp(
+ self.user_params['Keysight5GTestApp'])
+ self.testclass_results = collections.OrderedDict()
+ self.iperf_server = self.iperf_servers[0]
+ self.iperf_client = self.iperf_clients[0]
+ self.remote_server = ssh.connection.SshConnection(
+ ssh.settings.from_config(
+ self.user_params['RemoteServer']['ssh_config']))
+ if self.testclass_params.get('reload_scpi', 1):
+ self.keysight_test_app.import_scpi_file(
+ self.testclass_params['scpi_file'])
+ # Configure test retries
+ self.user_params['retry_tests'] = [self.__class__.__name__]
+
+ # Turn Airplane mode on
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+
+ def teardown_class(self):
+ self.log.info('Turning airplane mode on')
+ try:
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ except:
+ self.log.warning('Cannot perform teardown operations on DUT.')
+ try:
+ self.keysight_test_app.set_cell_state('LTE', 1, 0)
+ self.keysight_test_app.destroy()
+ except:
+ self.log.warning('Cannot perform teardown operations on tester.')
+ self.process_testclass_results()
+
+ def setup_test(self):
+ if self.testclass_params['enable_pixel_logs']:
+ cputils.start_pixel_logger(self.dut)
+
+ def on_retry(self):
+ """Function to control test logic on retried tests.
+
+ This function is automatically executed on tests that are being
+ retried. In this case the function resets wifi, toggles it off and on
+ and sets a retry_flag to enable further tweaking the test logic on
+ second attempts.
+ """
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ if self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE off.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 0)
+
+ def teardown_test(self):
+ self.log.info('Turing airplane mode on')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ log_path = os.path.join(
+ context.get_current_context().get_full_output_path(), 'pixel_logs')
+ os.makedirs(self.log_path, exist_ok=True)
+ if self.testclass_params['enable_pixel_logs']:
+ cputils.stop_pixel_logger(self.dut, log_path)
+ self.process_testcase_results()
+ self.pass_fail_check()
+
+ def process_testcase_results(self):
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+ testcase_result = testcase_data['results'][0]
+ metric_map = {
+ 'min_dl_tput':
+ testcase_result['tput_result']['total']['DL']['min_tput'],
+ 'max_dl_tput':
+ testcase_result['tput_result']['total']['DL']['max_tput'],
+ 'avg_dl_tput':
+ testcase_result['tput_result']['total']['DL']['average_tput'],
+ 'theoretical_dl_tput':
+ testcase_result['tput_result']['total']['DL']['theoretical_tput'],
+ 'dl_bler':
+ testcase_result['bler_result']['total']['DL']['nack_ratio'] * 100,
+ 'min_dl_tput':
+ testcase_result['tput_result']['total']['UL']['min_tput'],
+ 'max_dl_tput':
+ testcase_result['tput_result']['total']['UL']['max_tput'],
+ 'avg_dl_tput':
+ testcase_result['tput_result']['total']['UL']['average_tput'],
+ 'theoretical_dl_tput':
+ testcase_result['tput_result']['total']['UL']['theoretical_tput'],
+ 'ul_bler':
+ testcase_result['bler_result']['total']['UL']['nack_ratio'] * 100,
+ 'tcp_udp_tput':
+ testcase_result.get('iperf_throughput', float('nan'))
+ }
+ if self.publish_testcase_metrics:
+ for metric_name, metric_value in metric_map.items():
+ self.testcase_metric_logger.add_metric(metric_name,
+ metric_value)
+
+ def pass_fail_check(self):
+ pass
+
+ def process_testclass_results(self):
+ """Saves CSV with all test results to enable comparison."""
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ 'results.csv')
+ with open(results_file_path, 'w', newline='') as csvfile:
+ field_names = [
+ 'Band', 'Channel', 'DL Carriers', 'UL Carriers', 'DL MCS',
+ 'DL MIMO', 'UL MCS', 'UL MIMO', 'Cell Power',
+ 'DL Min. Throughput', 'DL Max. Throughput',
+ 'DL Avg. Throughput', 'DL Theoretical Throughput',
+ 'UL Min. Throughput', 'UL Max. Throughput',
+ 'UL Avg. Throughput', 'UL Theoretical Throughput',
+ 'DL BLER (%)', 'UL BLER (%)', 'TCP/UDP Throughput'
+ ]
+ writer = csv.DictWriter(csvfile, fieldnames=field_names)
+ writer.writeheader()
+
+ for testcase_name, testcase_results in self.testclass_results.items(
+ ):
+ for result in testcase_results['results']:
+ writer.writerow({
+ 'Band':
+ testcase_results['testcase_params']['band'],
+ 'Channel':
+ testcase_results['testcase_params']['channel'],
+ 'DL Carriers':
+ testcase_results['testcase_params']['num_dl_cells'],
+ 'UL Carriers':
+ testcase_results['testcase_params']['num_ul_cells'],
+ 'DL MCS':
+ testcase_results['testcase_params']['dl_mcs'],
+ 'DL MIMO':
+ testcase_results['testcase_params']['dl_mimo_config'],
+ 'UL MCS':
+ testcase_results['testcase_params']['ul_mcs'],
+ 'UL MIMO':
+ testcase_results['testcase_params']['ul_mimo_config'],
+ 'Cell Power':
+ result['cell_power'],
+ 'DL Min. Throughput':
+ result['tput_result']['total']['DL']['min_tput'],
+ 'DL Max. Throughput':
+ result['tput_result']['total']['DL']['max_tput'],
+ 'DL Avg. Throughput':
+ result['tput_result']['total']['DL']['average_tput'],
+ 'DL Theoretical Throughput':
+ result['tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'UL Min. Throughput':
+ result['tput_result']['total']['UL']['min_tput'],
+ 'UL Max. Throughput':
+ result['tput_result']['total']['UL']['max_tput'],
+ 'UL Avg. Throughput':
+ result['tput_result']['total']['UL']['average_tput'],
+ 'UL Theoretical Throughput':
+ result['tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'DL BLER (%)':
+ result['bler_result']['total']['DL']['nack_ratio'] *
+ 100,
+ 'UL BLER (%)':
+ result['bler_result']['total']['UL']['nack_ratio'] *
+ 100,
+ 'TCP/UDP Throughput':
+ result.get('iperf_throughput', 0)
+ })
+
+ def setup_tester(self, testcase_params):
+ if not self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE on.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 1)
+ self.log.info('Turning off airplane mode')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, False),
+ 'Can not turn on airplane mode.')
+ for cell in testcase_params['dl_cell_list']:
+ self.keysight_test_app.set_cell_band('NR5G', cell,
+ testcase_params['band'])
+ self.keysight_test_app.set_cell_mimo_config(
+ 'NR5G', cell, 'DL', testcase_params['dl_mimo_config'])
+ self.keysight_test_app.set_cell_dl_power(
+ 'NR5G', cell, testcase_params['cell_power_list'][0], 1)
+ for cell in testcase_params['ul_cell_list']:
+ self.keysight_test_app.set_cell_mimo_config(
+ 'NR5G', cell, 'UL', testcase_params['ul_mimo_config'])
+ self.keysight_test_app.configure_contiguous_nr_channels(
+ testcase_params['dl_cell_list'][0], testcase_params['band'],
+ testcase_params['channel'])
+ # Consider configuring schedule quick config
+ self.keysight_test_app.set_nr_cell_schedule_scenario(
+ testcase_params['dl_cell_list'][0],
+ testcase_params['schedule_scenario'])
+ self.keysight_test_app.set_nr_ul_dft_precoding(
+ testcase_params['dl_cell_list'][0],
+ testcase_params['transform_precoding'])
+ self.keysight_test_app.set_nr_cell_mcs(
+ testcase_params['dl_cell_list'][0], testcase_params['dl_mcs'],
+ testcase_params['ul_mcs'])
+ self.keysight_test_app.set_dl_carriers(testcase_params['dl_cell_list'])
+ self.keysight_test_app.set_ul_carriers(testcase_params['ul_cell_list'])
+ self.log.info('Waiting for LTE and applying aggregation')
+ if not self.keysight_test_app.wait_for_cell_status(
+ 'LTE', 'CELL1', 'CONN', 60):
+ asserts.fail('DUT did not connect to LTE.')
+ self.keysight_test_app.apply_carrier_agg()
+ self.log.info('Waiting for 5G connection')
+ connected = self.keysight_test_app.wait_for_cell_status(
+ 'NR5G', testcase_params['dl_cell_list'][-1], ['ACT', 'CONN'], 60)
+ if not connected:
+ asserts.fail('DUT did not connect to NR.')
+ time.sleep(SHORT_SLEEP)
+
+ def run_iperf_traffic(self, testcase_params):
+ self.iperf_server.start(tag=0)
+ dut_ip = self.dut.droid.connectivityGetIPv4Addresses('rmnet0')[0]
+ if 'iperf_server_address' in self.testclass_params:
+ iperf_server_address = self.testclass_params[
+ 'iperf_server_address']
+ elif isinstance(self.iperf_server, ipf.IPerfServerOverAdb):
+ iperf_server_address = dut_ip
+ else:
+ iperf_server_address = wputils.get_server_address(
+ self.remote_server, dut_ip, '255.255.255.0')
+ client_output_path = self.iperf_client.start(
+ iperf_server_address, testcase_params['iperf_args'], 0,
+ self.testclass_params['traffic_duration'] + IPERF_TIMEOUT)
+ server_output_path = self.iperf_server.stop()
+ # 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)
+ current_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')
+ current_throughput = 0
+ return current_throughput
+
+ def _test_nr_throughput_bler(self, testcase_params):
+ """Test function to run cellular throughput and BLER measurements.
+
+ The function runs BLER/throughput measurement after configuring the
+ callbox and DUT. The test supports running PHY or TCP/UDP layer traffic
+ in a variety of band/carrier/mcs/etc configurations.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ Returns:
+ result: dict containing throughput results and meta data
+ """
+ testcase_params = self.compile_test_params(testcase_params)
+ testcase_results = collections.OrderedDict()
+ testcase_results['testcase_params'] = testcase_params
+ testcase_results['results'] = []
+ # Setup tester and wait for DUT to connect
+ self.setup_tester(testcase_params)
+ # Run test
+ stop_counter = 0
+ for cell_power in testcase_params['cell_power_list']:
+ result = collections.OrderedDict()
+ result['cell_power'] = cell_power
+ # Set DL cell power
+ for cell in testcase_params['dl_cell_list']:
+ self.keysight_test_app.set_cell_dl_power(
+ 'NR5G', cell, result['cell_power'], 1)
+ self.keysight_test_app.select_display_tab(
+ 'NR5G', testcase_params['dl_cell_list'][0], 'BTHR', 'OTAGRAPH')
+ time.sleep(SHORT_SLEEP)
+ # Start BLER and throughput measurements
+ self.keysight_test_app.start_bler_measurement(
+ 'NR5G', testcase_params['dl_cell_list'],
+ testcase_params['bler_measurement_length'])
+ if self.testclass_params['traffic_type'] != 'PHY':
+ result['iperf_throughput'] = self.run_iperf_traffic(
+ testcase_params)
+ if self.testclass_params['log_power_metrics']:
+ if testcase_params[
+ 'bler_measurement_length'] >= 5000 and self.testclass_params[
+ 'traffic_type'] == 'PHY':
+ time.sleep(testcase_params['bler_measurement_length'] /
+ 1000 - 5)
+ cputils.log_system_power_metrics(self.dut, verbose=0)
+ else:
+ self.log.warning('Test too short to log metrics')
+
+ result['bler_result'] = self.keysight_test_app.get_bler_result(
+ 'NR5G', testcase_params['dl_cell_list'],
+ testcase_params['bler_measurement_length'])
+ result['tput_result'] = self.keysight_test_app.get_throughput(
+ 'NR5G', testcase_params['dl_cell_list'])
+
+ # Print Test Summary
+ self.log.info("Cell Power: {}dBm".format(cell_power))
+ self.log.info(
+ "DL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['tput_result']['total']['DL']['min_tput'],
+ result['tput_result']['total']['DL']['average_tput'],
+ result['tput_result']['total']['DL']['max_tput'],
+ result['tput_result']['total']['DL']['theoretical_tput']))
+ self.log.info(
+ "UL PHY Tput (Mbps):\tMin: {:.2f},\tAvg: {:.2f},\tMax: {:.2f},\tTheoretical: {:.2f}"
+ .format(
+ result['tput_result']['total']['UL']['min_tput'],
+ result['tput_result']['total']['UL']['average_tput'],
+ result['tput_result']['total']['UL']['max_tput'],
+ result['tput_result']['total']['UL']['theoretical_tput']))
+ self.log.info("DL BLER: {:.2f}%\tUL BLER: {:.2f}%".format(
+ result['bler_result']['total']['DL']['nack_ratio'] * 100,
+ result['bler_result']['total']['UL']['nack_ratio'] * 100))
+ testcase_results['results'].append(result)
+ if self.testclass_params['traffic_type'] != 'PHY':
+ self.log.info("{} {} Tput: {:.2f} Mbps".format(
+ self.testclass_params['traffic_type'],
+ testcase_params['traffic_direction'],
+ result['iperf_throughput']))
+
+ if result['bler_result']['total']['DL']['nack_ratio'] * 100 > 99:
+ stop_counter = stop_counter + 1
+ else:
+ stop_counter = 0
+ if stop_counter == STOP_COUNTER_LIMIT:
+ break
+ # Turn off NR cells
+ for cell in testcase_params['dl_cell_list'][::-1]:
+ self.keysight_test_app.set_cell_state('NR5G', cell, 0)
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+
+ # Save results
+ self.testclass_results[self.current_test_name] = testcase_results
+
+ def compile_test_params(self, testcase_params):
+ """Function that completes all test params based on the test name.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ """
+ testcase_params['bler_measurement_length'] = int(
+ self.testclass_params['traffic_duration'] / SUBFRAME_LENGTH)
+ testcase_params['cell_power_list'] = numpy.arange(
+ self.testclass_params['cell_power_start'],
+ self.testclass_params['cell_power_stop'],
+ self.testclass_params['cell_power_step'])
+ if self.testclass_params['traffic_type'] == 'PHY':
+ return testcase_params
+ if self.testclass_params['traffic_type'] == 'TCP':
+ testcase_params['iperf_socket_size'] = self.testclass_params.get(
+ 'tcp_socket_size', None)
+ testcase_params['iperf_processes'] = self.testclass_params.get(
+ 'tcp_processes', 1)
+ elif self.testclass_params['traffic_type'] == 'UDP':
+ testcase_params['iperf_socket_size'] = self.testclass_params.get(
+ 'udp_socket_size', None)
+ testcase_params['iperf_processes'] = self.testclass_params.get(
+ 'udp_processes', 1)
+ if (testcase_params['traffic_direction'] == 'DL'
+ and not isinstance(self.iperf_server, ipf.IPerfServerOverAdb)
+ ) or (testcase_params['traffic_direction'] == 'UL'
+ and isinstance(self.iperf_server, ipf.IPerfServerOverAdb)):
+ testcase_params['iperf_args'] = wputils.get_iperf_arg_string(
+ duration=self.testclass_params['traffic_duration'],
+ reverse_direction=1,
+ traffic_type=self.testclass_params['traffic_type'],
+ socket_size=testcase_params['iperf_socket_size'],
+ num_processes=testcase_params['iperf_processes'],
+ udp_throughput=self.testclass_params['UDP_rates'].get(
+ testcase_params['num_dl_cells'],
+ self.testclass_params['UDP_rates']["default"]),
+ udp_length=1440)
+ testcase_params['use_client_output'] = True
+ elif (testcase_params['traffic_direction'] == 'UL'
+ and not isinstance(self.iperf_server, ipf.IPerfServerOverAdb)
+ ) or (testcase_params['traffic_direction'] == 'DL'
+ and isinstance(self.iperf_server, ipf.IPerfServerOverAdb)):
+ testcase_params['iperf_args'] = wputils.get_iperf_arg_string(
+ duration=self.testclass_params['traffic_duration'],
+ reverse_direction=0,
+ traffic_type=self.testclass_params['traffic_type'],
+ socket_size=testcase_params['iperf_socket_size'],
+ num_processes=testcase_params['iperf_processes'],
+ udp_throughput=self.testclass_params['UDP_rates'].get(
+ testcase_params['num_dl_cells'],
+ self.testclass_params['UDP_rates']["default"]),
+ udp_length=1440)
+ testcase_params['use_client_output'] = False
+ return testcase_params
+
+ def generate_test_cases(self, bands, channels, mcs_pair_list,
+ num_dl_cells_list, num_ul_cells_list,
+ dl_mimo_config, ul_mimo_config, **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = ['test_load_scpi']
+
+ for band, channel, num_ul_cells, num_dl_cells, mcs_pair in itertools.product(
+ bands, channels, num_ul_cells_list, num_dl_cells_list,
+ mcs_pair_list):
+ if num_ul_cells > num_dl_cells:
+ continue
+ if channel not in cputils.PCC_PRESET_MAPPING[band]:
+ continue
+ test_name = 'test_nr_throughput_bler_{}_{}_DL_{}CC_mcs{}_{}_UL_{}CC_mcs{}_{}'.format(
+ band, channel, num_dl_cells, mcs_pair[0], dl_mimo_config,
+ num_ul_cells, mcs_pair[1], ul_mimo_config)
+ test_params = collections.OrderedDict(
+ band=band,
+ channel=channel,
+ dl_mcs=mcs_pair[0],
+ ul_mcs=mcs_pair[1],
+ num_dl_cells=num_dl_cells,
+ num_ul_cells=num_ul_cells,
+ dl_mimo_config=dl_mimo_config,
+ ul_mimo_config=ul_mimo_config,
+ dl_cell_list=list(range(1, num_dl_cells + 1)),
+ ul_cell_list=list(range(1, num_ul_cells + 1)),
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_nr_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
+class Cellular5GFR2_DL_ThroughputTest(Cellular5GFR2ThroughputTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(16, 4), (27, 4)],
+ list(range(1, 9)),
+ list(range(1, 3)),
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N1X1',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0)
+
+
+class Cellular5GFR2_CP_UL_ThroughputTest(Cellular5GFR2ThroughputTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N1X1',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0)
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [2], [2],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [3], [3],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="UL_RMC",
+ traffic_direction='UL',
+ transform_precoding=0))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [4], [4],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0))
+
+
+class Cellular5GFR2_DFTS_UL_ThroughputTest(Cellular5GFR2ThroughputTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N1X1',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1)
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [2], [2],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [3], [3],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [4], [4],
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N2X2',
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1))
+
+
+class Cellular5GFR2_DL_FrequecySweep_ThroughputTest(Cellular5GFR2ThroughputTest
+ ):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ dl_frequency_sweep_params = self.user_params['throughput_test_params'][
+ 'dl_frequency_sweep']
+ self.tests = self.generate_test_cases(dl_frequency_sweep_params,
+ [(16, 4), (27, 4)],
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0,
+ dl_mimo_config='N2X2',
+ ul_mimo_config='N1X1')
+
+ def generate_test_cases(self, dl_frequency_sweep_params, mcs_pair_list,
+ **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = ['test_load_scpi']
+
+ for band, band_config in dl_frequency_sweep_params.items():
+ for num_dl_cells_str, sweep_config in band_config.items():
+ num_dl_cells = int(num_dl_cells_str[0])
+ num_ul_cells = 1
+ freq_vector = numpy.arange(sweep_config[0], sweep_config[1],
+ sweep_config[2])
+ for freq in freq_vector:
+ for mcs_pair in mcs_pair_list:
+ test_name = 'test_nr_throughput_bler_{}_{}MHz_DL_{}CC_mcs{}_UL_{}CC_mcs{}'.format(
+ band, freq, num_dl_cells, mcs_pair[0],
+ num_ul_cells, mcs_pair[1])
+ test_params = collections.OrderedDict(
+ band=band,
+ channel=freq,
+ dl_mcs=mcs_pair[0],
+ ul_mcs=mcs_pair[1],
+ num_dl_cells=num_dl_cells,
+ num_ul_cells=num_ul_cells,
+ dl_cell_list=list(range(1, num_dl_cells + 1)),
+ ul_cell_list=list(range(1, num_ul_cells + 1)),
+ **kwargs)
+ setattr(
+ self, test_name,
+ partial(self._test_nr_throughput_bler,
+ test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularFr1SensitivityTest.py b/acts_tests/tests/google/cellular/performance/CellularFr1SensitivityTest.py
new file mode 100644
index 0000000..e483e59
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularFr1SensitivityTest.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import numpy
+import json
+import os
+from acts import context
+from acts import base_test
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure import BokehFigure
+from CellularLtePlusFr1PeakThroughputTest import CellularFr1SingleCellPeakThroughputTest
+
+from functools import partial
+
+
+class CellularFr1SensitivityTest(CellularFr1SingleCellPeakThroughputTest):
+ """Class to test single cell FR1 NSA sensitivity"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['nr_sensitivity_test_params']
+ self.tests = self.generate_test_cases(
+ channel_list=['LOW', 'MID', 'HIGH'],
+ dl_mcs_list=list(numpy.arange(27, -1, -1)),
+ nr_ul_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_dl_mcs=4,
+ lte_ul_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ transform_precoding=0)
+
+ def process_testclass_results(self):
+ # Plot individual test id results raw data and compile metrics
+ plots = collections.OrderedDict()
+ compiled_data = collections.OrderedDict()
+ for testcase_name, testcase_data in self.testclass_results.items():
+ cell_config = testcase_data['testcase_params'][
+ 'endc_combo_config']['cell_list'][1]
+ test_id = tuple(('band', cell_config['band']))
+ if test_id not in plots:
+ # Initialize test id data when not present
+ compiled_data[test_id] = {
+ 'mcs': [],
+ 'average_throughput': [],
+ 'theoretical_throughput': [],
+ 'cell_power': [],
+ }
+ plots[test_id] = BokehFigure(
+ title='Band {} - BLER Curves'.format(cell_config['band']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='BLER (Mbps)')
+ test_id_rvr = test_id + tuple('RvR')
+ plots[test_id_rvr] = BokehFigure(
+ title='Band {} - RvR'.format(cell_config['band']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='PHY Rate (Mbps)')
+ # Compile test id data and metrics
+ compiled_data[test_id]['average_throughput'].append(
+ testcase_data['average_throughput_list'])
+ compiled_data[test_id]['cell_power'].append(
+ testcase_data['cell_power_list'])
+ compiled_data[test_id]['mcs'].append(
+ testcase_data['testcase_params']['nr_dl_mcs'])
+ # Add test id to plots
+ plots[test_id].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['bler_list'],
+ 'MCS {}'.format(testcase_data['testcase_params']['nr_dl_mcs']),
+ width=1)
+ plots[test_id_rvr].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['average_throughput_list'],
+ 'MCS {}'.format(testcase_data['testcase_params']['nr_dl_mcs']),
+ width=1,
+ style='dashed')
+
+ # Compute average RvRs and compute metrics over orientations
+ for test_id, test_data in compiled_data.items():
+ test_id_rvr = test_id + tuple('RvR')
+ cell_power_interp = sorted(set(sum(test_data['cell_power'], [])))
+ average_throughput_interp = []
+ for mcs, cell_power, throughput in zip(
+ test_data['mcs'], test_data['cell_power'],
+ test_data['average_throughput']):
+ throughput_interp = numpy.interp(cell_power_interp,
+ cell_power[::-1],
+ throughput[::-1])
+ average_throughput_interp.append(throughput_interp)
+ rvr = numpy.max(average_throughput_interp, 0)
+ plots[test_id_rvr].add_line(cell_power_interp, rvr,
+ 'Rate vs. Range')
+
+ figure_list = []
+ for plot_id, plot in plots.items():
+ plot.generate_figure()
+ figure_list.append(plot)
+ output_file_path = os.path.join(self.log_path, 'results.html')
+ BokehFigure.save_figures(figure_list, output_file_path)
+
+ def process_testcase_results(self):
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+
+ bler_list = []
+ average_throughput_list = []
+ theoretical_throughput_list = []
+ cell_power_list = testcase_data['testcase_params']['cell_power_sweep'][
+ 1]
+ for result in testcase_data['results']:
+ bler_list.append(
+ result['nr_bler_result']['total']['DL']['nack_ratio'])
+ average_throughput_list.append(
+ result['nr_tput_result']['total']['DL']['average_tput'])
+ theoretical_throughput_list.append(
+ result['nr_tput_result']['total']['DL']['theoretical_tput'])
+ padding_len = len(cell_power_list) - len(average_throughput_list)
+ average_throughput_list.extend([0] * padding_len)
+ theoretical_throughput_list.extend([0] * padding_len)
+
+ bler_above_threshold = [
+ bler > self.testclass_params['bler_threshold']
+ for bler in bler_list
+ ]
+ for idx in range(len(bler_above_threshold)):
+ if all(bler_above_threshold[idx:]):
+ sensitivity_idx = max(idx, 1) - 1
+ break
+ else:
+ sensitivity_idx = -1
+ sensitivity = cell_power_list[sensitivity_idx]
+ self.log.info('NR Band {} MCS {} Sensitivity = {}dBm'.format(
+ testcase_data['testcase_params']['endc_combo_config']['cell_list']
+ [1]['band'], testcase_data['testcase_params']['nr_dl_mcs'],
+ sensitivity))
+
+ testcase_data['bler_list'] = bler_list
+ testcase_data['average_throughput_list'] = average_throughput_list
+ testcase_data[
+ 'theoretical_throughput_list'] = theoretical_throughput_list
+ testcase_data['cell_power_list'] = cell_power_list
+ testcase_data['sensitivity'] = sensitivity
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ # get reference test
+ current_band = testcase_params['endc_combo_config']['cell_list'][1][
+ 'band']
+ reference_test = None
+ reference_sensitivity = None
+ for testcase_name, testcase_data in self.testclass_results.items():
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'cell_list'][1]['band'] == current_band:
+ reference_test = testcase_name
+ reference_sensitivity = testcase_data['sensitivity']
+ if reference_test and reference_sensitivity and not self.retry_flag:
+ start_atten = reference_sensitivity + self.testclass_params[
+ 'adjacent_mcs_gap']
+ self.log.info(
+ "Reference test {} found. Sensitivity {} dBm. Starting at {} dBm"
+ .format(reference_test, reference_sensitivity, start_atten))
+ else:
+ start_atten = self.testclass_params['nr_cell_power_start']
+ self.log.info(
+ "Reference test not found. Starting at {} dBm".format(
+ start_atten))
+ # get current cell power start
+ nr_cell_sweep = list(
+ numpy.arange(start_atten,
+ self.testclass_params['nr_cell_power_stop'],
+ self.testclass_params['nr_cell_power_step']))
+ lte_sweep = [self.testclass_params['lte_cell_power']
+ ] * len(nr_cell_sweep)
+ cell_power_sweeps = [lte_sweep, nr_cell_sweep]
+ return cell_power_sweeps
+
+ def generate_test_cases(self, channel_list, dl_mcs_list, **kwargs):
+ test_cases = []
+ with open(self.testclass_params['nr_single_cell_configs'],
+ 'r') as csvfile:
+ test_configs = csv.DictReader(csvfile)
+ for test_config, channel, nr_dl_mcs in itertools.product(
+ test_configs, channel_list, dl_mcs_list):
+ if int(test_config['skip_test']):
+ continue
+ endc_combo_config = self.generate_endc_combo_config(
+ test_config)
+ test_name = 'test_fr1_{}_{}_dl_mcs{}'.format(
+ test_config['nr_band'], channel.lower(), nr_dl_mcs)
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=nr_dl_mcs,
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularFr2PeakThroughputTest.py b/acts_tests/tests/google/cellular/performance/CellularFr2PeakThroughputTest.py
new file mode 100644
index 0000000..848832e
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularFr2PeakThroughputTest.py
@@ -0,0 +1,602 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import json
+import re
+import numpy
+import os
+from acts import context
+from acts import base_test
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.cellular.performance.CellularThroughputBaseTest import CellularThroughputBaseTest
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+
+from functools import partial
+
+LONG_SLEEP = 10
+MEDIUM_SLEEP = 2
+IPERF_TIMEOUT = 10
+SHORT_SLEEP = 1
+SUBFRAME_LENGTH = 0.001
+STOP_COUNTER_LIMIT = 3
+
+
+class CellularFr2PeakThroughputTest(CellularThroughputBaseTest):
+ """Base class to test cellular FR2 throughput
+
+ This class implements cellular FR2 throughput tests on a callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+
+ def process_testcase_results(self):
+ """Publish test case metrics and save results"""
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+ testcase_result = testcase_data['results'][0]
+ metric_map = {
+ 'tcp_udp_tput': testcase_result.get('iperf_throughput',
+ float('nan'))
+ }
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'nr_cell_count']:
+ metric_map.update({
+ 'nr_min_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']['min_tput'],
+ 'nr_max_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']['max_tput'],
+ 'nr_avg_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']
+ ['average_tput'],
+ 'nr_theoretical_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'nr_dl_bler':
+ testcase_result['nr_bler_result']['total']['DL']['nack_ratio']
+ * 100,
+ 'nr_min_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']['min_tput'],
+ 'nr_max_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']['max_tput'],
+ 'nr_avg_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']
+ ['average_tput'],
+ 'nr_theoretical_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'nr_ul_bler':
+ testcase_result['nr_bler_result']['total']['UL']['nack_ratio']
+ * 100
+ })
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'lte_cell_count']:
+ metric_map.update({
+ 'lte_min_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']['min_tput'],
+ 'lte_max_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']['max_tput'],
+ 'lte_avg_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']
+ ['average_tput'],
+ 'lte_theoretical_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'lte_dl_bler':
+ testcase_result['lte_bler_result']['total']['DL']['nack_ratio']
+ * 100,
+ 'lte_min_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']['min_tput'],
+ 'lte_max_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']['max_tput'],
+ 'lte_avg_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']
+ ['average_tput'],
+ 'lte_theoretical_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'lte_ul_bler':
+ testcase_result['lte_bler_result']['total']['UL']['nack_ratio']
+ * 100
+ })
+ if self.publish_testcase_metrics:
+ for metric_name, metric_value in metric_map.items():
+ self.testcase_metric_logger.add_metric(metric_name,
+ metric_value)
+
+ def process_testclass_results(self):
+ """Saves CSV with all test results to enable comparison."""
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ 'results.csv')
+ with open(results_file_path, 'w', newline='') as csvfile:
+ field_names = [
+ 'Test Name', 'NR DL Min. Throughput', 'NR DL Max. Throughput',
+ 'NR DL Avg. Throughput', 'NR DL Theoretical Throughput',
+ 'NR UL Min. Throughput', 'NR UL Max. Throughput',
+ 'NR UL Avg. Throughput', 'NR UL Theoretical Throughput',
+ 'NR DL BLER (%)', 'NR UL BLER (%)', 'LTE DL Min. Throughput',
+ 'LTE DL Max. Throughput', 'LTE DL Avg. Throughput',
+ 'LTE DL Theoretical Throughput', 'LTE UL Min. Throughput',
+ 'LTE UL Max. Throughput', 'LTE UL Avg. Throughput',
+ 'LTE UL Theoretical Throughput', 'LTE DL BLER (%)',
+ 'LTE UL BLER (%)', 'TCP/UDP Throughput'
+ ]
+ writer = csv.DictWriter(csvfile, fieldnames=field_names)
+ writer.writeheader()
+
+ for testcase_name, testcase_results in self.testclass_results.items(
+ ):
+ for result in testcase_results['results']:
+ row_dict = {
+ 'Test Name': testcase_name,
+ 'TCP/UDP Throughput':
+ result.get('iperf_throughput', 0)
+ }
+ if testcase_results['testcase_params'][
+ 'endc_combo_config']['nr_cell_count']:
+ row_dict.update({
+ 'NR DL Min. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['min_tput'],
+ 'NR DL Max. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['max_tput'],
+ 'NR DL Avg. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['average_tput'],
+ 'NR DL Theoretical Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'NR UL Min. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['min_tput'],
+ 'NR UL Max. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['max_tput'],
+ 'NR UL Avg. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['average_tput'],
+ 'NR UL Theoretical Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'NR DL BLER (%)':
+ result['nr_bler_result']['total']['DL']
+ ['nack_ratio'] * 100,
+ 'NR UL BLER (%)':
+ result['nr_bler_result']['total']['UL']
+ ['nack_ratio'] * 100
+ })
+ if testcase_results['testcase_params'][
+ 'endc_combo_config']['lte_cell_count']:
+ row_dict.update({
+ 'LTE DL Min. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['min_tput'],
+ 'LTE DL Max. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['max_tput'],
+ 'LTE DL Avg. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['average_tput'],
+ 'LTE DL Theoretical Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'LTE UL Min. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['min_tput'],
+ 'LTE UL Max. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['max_tput'],
+ 'LTE UL Avg. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['average_tput'],
+ 'LTE UL Theoretical Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'LTE DL BLER (%)':
+ result['lte_bler_result']['total']['DL']
+ ['nack_ratio'] * 100,
+ 'LTE UL BLER (%)':
+ result['lte_bler_result']['total']['UL']
+ ['nack_ratio'] * 100
+ })
+ writer.writerow(row_dict)
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ """Function to get per cell power sweep lists
+
+ Args:
+ testcase_params: dict containing all test case params
+ Returns:
+ cell_power_sweeps: list of cell power sweeps for each cell under test
+ """
+ cell_power_sweeps = []
+ for cell in testcase_params['endc_combo_config']['cell_list']:
+ if cell['cell_type'] == 'LTE':
+ sweep = [self.testclass_params['lte_cell_power']]
+ else:
+ sweep = [self.testclass_params['nr_cell_power']]
+ cell_power_sweeps.append(sweep)
+ return cell_power_sweeps
+
+ def generate_endc_combo_config(self, test_config):
+ """Function to generate ENDC combo config from CSV test config
+
+ Args:
+ test_config: dict containing ENDC combo config from CSV
+ Returns:
+ endc_combo_config: dictionary with all ENDC combo settings
+ """
+ endc_combo_config = collections.OrderedDict()
+ cell_config_list = []
+
+ lte_cell_count = 1
+ lte_carriers = [1]
+ lte_scc_list = []
+ endc_combo_config['lte_pcc'] = 1
+ lte_cell = {
+ 'cell_type':
+ 'LTE',
+ 'cell_number':
+ 1,
+ 'pcc':
+ 1,
+ 'band':
+ test_config['lte_band'],
+ 'dl_bandwidth':
+ test_config['lte_bandwidth'],
+ 'ul_enabled':
+ 1,
+ 'duplex_mode':
+ test_config['lte_duplex_mode'],
+ 'dl_mimo_config':
+ 'D{nss}U{nss}'.format(nss=test_config['lte_dl_mimo_config']),
+ 'ul_mimo_config':
+ 'D{nss}U{nss}'.format(nss=test_config['lte_ul_mimo_config']),
+ 'transmission_mode':
+ 'TM1'
+ }
+ cell_config_list.append(lte_cell)
+
+ nr_cell_count = 0
+ nr_dl_carriers = []
+ nr_ul_carriers = []
+ for nr_cell_idx in range(1, test_config['num_dl_cells'] + 1):
+ nr_cell = {
+ 'cell_type':
+ 'NR5G',
+ 'cell_number':
+ nr_cell_idx,
+ 'band':
+ test_config['nr_band'],
+ 'duplex_mode':
+ test_config['nr_duplex_mode'],
+ 'channel':
+ test_config['nr_channel'],
+ 'dl_mimo_config':
+ 'N{nss}X{nss}'.format(nss=test_config['nr_dl_mimo_config']),
+ 'dl_bandwidth_class':
+ 'A',
+ 'dl_bandwidth':
+ test_config['nr_bandwidth'],
+ 'ul_enabled':
+ 1 if nr_cell_idx <= test_config['num_ul_cells'] else 0,
+ 'ul_bandwidth_class':
+ 'A',
+ 'ul_mimo_config':
+ 'N{nss}X{nss}'.format(nss=test_config['nr_ul_mimo_config']),
+ 'subcarrier_spacing':
+ 'MU3'
+ }
+ cell_config_list.append(nr_cell)
+ nr_cell_count = nr_cell_count + 1
+ nr_dl_carriers.append(nr_cell_idx)
+ if nr_cell_idx <= test_config['num_ul_cells']:
+ nr_ul_carriers.append(nr_cell_idx)
+
+ endc_combo_config['lte_cell_count'] = lte_cell_count
+ endc_combo_config['nr_cell_count'] = nr_cell_count
+ endc_combo_config['nr_dl_carriers'] = nr_dl_carriers
+ endc_combo_config['nr_ul_carriers'] = nr_ul_carriers
+ endc_combo_config['cell_list'] = cell_config_list
+ endc_combo_config['lte_scc_list'] = lte_scc_list
+ endc_combo_config['lte_carriers'] = lte_carriers
+ return endc_combo_config
+
+ def generate_test_cases(self, bands, channels, nr_mcs_pair_list,
+ num_dl_cells_list, num_ul_cells_list,
+ dl_mimo_config, ul_mimo_config, **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+ for band, channel, num_ul_cells, num_dl_cells, nr_mcs_pair in itertools.product(
+ bands, channels, num_ul_cells_list, num_dl_cells_list,
+ nr_mcs_pair_list):
+ if num_ul_cells > num_dl_cells:
+ continue
+ if channel not in cputils.PCC_PRESET_MAPPING[band]:
+ continue
+ test_config = {
+ 'lte_band': 2,
+ 'lte_bandwidth': 'BW20',
+ 'lte_duplex_mode': 'FDD',
+ 'lte_dl_mimo_config': 1,
+ 'lte_ul_mimo_config': 1,
+ 'nr_band': band,
+ 'nr_bandwidth': 'BW100',
+ 'nr_duplex_mode': 'TDD',
+ 'nr_channel': channel,
+ 'num_dl_cells': num_dl_cells,
+ 'num_ul_cells': num_ul_cells,
+ 'nr_dl_mimo_config': dl_mimo_config,
+ 'nr_ul_mimo_config': ul_mimo_config
+ }
+ endc_combo_config = self.generate_endc_combo_config(test_config)
+ test_name = 'test_fr2_{}_{}_DL_{}CC_mcs{}_{}x{}_UL_{}CC_mcs{}_{}x{}'.format(
+ band, channel, num_dl_cells, nr_mcs_pair[0], dl_mimo_config,
+ dl_mimo_config, num_ul_cells, nr_mcs_pair[1], ul_mimo_config,
+ ul_mimo_config)
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=nr_mcs_pair[0],
+ nr_ul_mcs=nr_mcs_pair[1],
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
+class CellularFr2DlPeakThroughputTest(CellularFr2PeakThroughputTest):
+ """Base class to test cellular FR2 throughput
+
+ This class implements cellular FR2 throughput tests on a callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(16, 4), (27, 4)],
+ list(range(1, 9)),
+ list(range(1, 3)),
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=1,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64')
+
+
+class CellularFr2CpOfdmUlPeakThroughputTest(CellularFr2PeakThroughputTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=1,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64')
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [2], [2],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [4], [4],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+
+
+class CellularFr2DftsOfdmUlPeakThroughputTest(CellularFr2PeakThroughputTest):
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=1,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64')
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [1], [1],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [2], [2],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+ self.tests.extend(
+ self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ ['low', 'mid', 'high'],
+ [(4, 16), (4, 27)], [4], [4],
+ force_contiguous_nr_channel=True,
+ dl_mimo_config=2,
+ ul_mimo_config=2,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='UL',
+ transform_precoding=1,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64'))
+
+
+class CellularFr2DlFrequencySweepPeakThroughputTest(
+ CellularFr2PeakThroughputTest):
+ """Base class to test cellular FR2 throughput
+
+ This class implements cellular FR2 throughput tests on a callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(
+ ['N257', 'N258', 'N260', 'N261'],
+ self.user_params['throughput_test_params']['frequency_sweep'],
+ [(16, 4), (27, 4)],
+ force_contiguous_nr_channel=False,
+ dl_mimo_config=2,
+ ul_mimo_config=1,
+ schedule_scenario="FULL_TPUT",
+ traffic_direction='DL',
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64')
+
+ def generate_test_cases(self, bands, channels, nr_mcs_pair_list,
+ num_dl_cells_list, num_ul_cells_list,
+ dl_mimo_config, ul_mimo_config, **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+ for band, channel, num_ul_cells, num_dl_cells, nr_mcs_pair in itertools.product(
+ bands, channels, num_ul_cells_list, num_dl_cells_list,
+ nr_mcs_pair_list):
+ if num_ul_cells > num_dl_cells:
+ continue
+ if channel not in cputils.PCC_PRESET_MAPPING[band]:
+ continue
+ test_config = {
+ 'lte_band': 2,
+ 'lte_bandwidth': 'BW20',
+ 'lte_duplex_mode': 'FDD',
+ 'lte_dl_mimo_config': 1,
+ 'lte_ul_mimo_config': 1,
+ 'nr_band': band,
+ 'nr_bandwidth': 'BW100',
+ 'nr_duplex_mode': 'TDD',
+ 'nr_channel': channel,
+ 'num_dl_cells': num_dl_cells,
+ 'num_ul_cells': num_ul_cells,
+ 'nr_dl_mimo_config': dl_mimo_config,
+ 'nr_ul_mimo_config': ul_mimo_config
+ }
+ endc_combo_config = self.generate_endc_combo_config(test_config)
+ test_name = 'test_fr2_{}_{}_DL_{}CC_mcs{}_{}x{}_UL_{}CC_mcs{}_{}x{}'.format(
+ band, channel, num_dl_cells, nr_mcs_pair[0], dl_mimo_config,
+ dl_mimo_config, num_ul_cells, nr_mcs_pair[1], ul_mimo_config,
+ ul_mimo_config)
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=nr_mcs_pair[0],
+ nr_ul_mcs=nr_mcs_pair[1],
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularFr2SensitivityTest.py b/acts_tests/tests/google/cellular/performance/CellularFr2SensitivityTest.py
new file mode 100644
index 0000000..4176a62
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularFr2SensitivityTest.py
@@ -0,0 +1,250 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import numpy
+import json
+import os
+from acts import context
+from acts import base_test
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure import BokehFigure
+from CellularFr2PeakThroughputTest import CellularFr2PeakThroughputTest
+
+from functools import partial
+
+
+class CellularFr2SensitivityTest(CellularFr2PeakThroughputTest):
+ """Class to test single cell FR1 NSA sensitivity"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['nr_sensitivity_test_params']
+ self.log.info('Hello')
+ self.tests = self.generate_test_cases(
+ band_list=['N257', 'N258', 'N260', 'N261'],
+ channel_list=['low', 'mid', 'high'],
+ dl_mcs_list=list(numpy.arange(27, -1, -1)),
+ num_dl_cells_list=[1, 2, 4, 8],
+ dl_mimo_config=2,
+ nr_ul_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_dl_mcs=4,
+ lte_ul_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ schedule_scenario="FULL_TPUT",
+ force_contiguous_nr_channel=True,
+ transform_precoding=0)
+
+ def process_testclass_results(self):
+ # Plot individual test id results raw data and compile metrics
+ plots = collections.OrderedDict()
+ compiled_data = collections.OrderedDict()
+ for testcase_name, testcase_data in self.testclass_results.items():
+ cell_config = testcase_data['testcase_params'][
+ 'endc_combo_config']['cell_list'][1]
+ test_id = tuple(('band', cell_config['band']))
+ if test_id not in plots:
+ # Initialize test id data when not present
+ compiled_data[test_id] = {
+ 'mcs': [],
+ 'average_throughput': [],
+ 'theoretical_throughput': [],
+ 'cell_power': [],
+ }
+ plots[test_id] = BokehFigure(
+ title='Band {} - BLER Curves'.format(cell_config['band']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='BLER (Mbps)')
+ test_id_rvr = test_id + tuple('RvR')
+ plots[test_id_rvr] = BokehFigure(
+ title='Band {} - RvR'.format(cell_config['band']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='PHY Rate (Mbps)')
+ # Compile test id data and metrics
+ compiled_data[test_id]['average_throughput'].append(
+ testcase_data['average_throughput_list'])
+ compiled_data[test_id]['cell_power'].append(
+ testcase_data['cell_power_list'])
+ compiled_data[test_id]['mcs'].append(
+ testcase_data['testcase_params']['nr_dl_mcs'])
+ # Add test id to plots
+ plots[test_id].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['bler_list'],
+ 'MCS {}'.format(testcase_data['testcase_params']['nr_dl_mcs']),
+ width=1)
+ plots[test_id_rvr].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['average_throughput_list'],
+ 'MCS {}'.format(testcase_data['testcase_params']['nr_dl_mcs']),
+ width=1,
+ style='dashed')
+
+ # Compute average RvRs and compute metrics over orientations
+ for test_id, test_data in compiled_data.items():
+ test_id_rvr = test_id + tuple('RvR')
+ cell_power_interp = sorted(set(sum(test_data['cell_power'], [])))
+ average_throughput_interp = []
+ for mcs, cell_power, throughput in zip(
+ test_data['mcs'], test_data['cell_power'],
+ test_data['average_throughput']):
+ throughput_interp = numpy.interp(cell_power_interp,
+ cell_power[::-1],
+ throughput[::-1])
+ average_throughput_interp.append(throughput_interp)
+ rvr = numpy.max(average_throughput_interp, 0)
+ plots[test_id_rvr].add_line(cell_power_interp, rvr,
+ 'Rate vs. Range')
+
+ figure_list = []
+ for plot_id, plot in plots.items():
+ plot.generate_figure()
+ figure_list.append(plot)
+ output_file_path = os.path.join(self.log_path, 'results.html')
+ BokehFigure.save_figures(figure_list, output_file_path)
+
+ def process_testcase_results(self):
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+
+ bler_list = []
+ average_throughput_list = []
+ theoretical_throughput_list = []
+ cell_power_list = testcase_data['testcase_params']['cell_power_sweep'][
+ 1]
+ for result in testcase_data['results']:
+ bler_list.append(
+ result['nr_bler_result']['total']['DL']['nack_ratio'])
+ average_throughput_list.append(
+ result['nr_tput_result']['total']['DL']['average_tput'])
+ theoretical_throughput_list.append(
+ result['nr_tput_result']['total']['DL']['theoretical_tput'])
+ padding_len = len(cell_power_list) - len(average_throughput_list)
+ average_throughput_list.extend([0] * padding_len)
+ theoretical_throughput_list.extend([0] * padding_len)
+
+ bler_above_threshold = [
+ bler > self.testclass_params['bler_threshold']
+ for bler in bler_list
+ ]
+ for idx in range(len(bler_above_threshold)):
+ if all(bler_above_threshold[idx:]):
+ sensitivity_idx = max(idx, 1) - 1
+ break
+ else:
+ sensitivity_idx = -1
+ sensitivity = cell_power_list[sensitivity_idx]
+ self.log.info('NR Band {} MCS {} Sensitivity = {}dBm'.format(
+ testcase_data['testcase_params']['endc_combo_config']['cell_list']
+ [1]['band'], testcase_data['testcase_params']['nr_dl_mcs'],
+ sensitivity))
+
+ testcase_data['bler_list'] = bler_list
+ testcase_data['average_throughput_list'] = average_throughput_list
+ testcase_data[
+ 'theoretical_throughput_list'] = theoretical_throughput_list
+ testcase_data['cell_power_list'] = cell_power_list
+ testcase_data['sensitivity'] = sensitivity
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ # get reference test
+ current_band = testcase_params['endc_combo_config']['cell_list'][1][
+ 'band']
+ reference_test = None
+ reference_sensitivity = None
+ for testcase_name, testcase_data in self.testclass_results.items():
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'cell_list'][1]['band'] == current_band:
+ reference_test = testcase_name
+ reference_sensitivity = testcase_data['sensitivity']
+ if reference_test and reference_sensitivity and not self.retry_flag:
+ start_atten = reference_sensitivity + self.testclass_params[
+ 'adjacent_mcs_gap']
+ self.log.info(
+ "Reference test {} found. Sensitivity {} dBm. Starting at {} dBm"
+ .format(reference_test, reference_sensitivity, start_atten))
+ else:
+ start_atten = self.testclass_params['nr_cell_power_start']
+ self.log.info(
+ "Reference test not found. Starting at {} dBm".format(
+ start_atten))
+ # get current cell power start
+ nr_cell_sweep = list(
+ numpy.arange(start_atten,
+ self.testclass_params['nr_cell_power_stop'],
+ self.testclass_params['nr_cell_power_step']))
+ lte_sweep = [self.testclass_params['lte_cell_power']
+ ] * len(nr_cell_sweep)
+ cell_power_sweeps = [lte_sweep]
+ cell_power_sweeps.extend(
+ [nr_cell_sweep] *
+ testcase_params['endc_combo_config']['nr_cell_count'])
+ return cell_power_sweeps
+
+ def generate_test_cases(self, band_list, channel_list, dl_mcs_list,
+ num_dl_cells_list, dl_mimo_config, **kwargs):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+ for band, channel, num_dl_cells, nr_dl_mcs in itertools.product(
+ band_list, channel_list, num_dl_cells_list, dl_mcs_list):
+ if channel not in cputils.PCC_PRESET_MAPPING[band]:
+ continue
+ test_config = {
+ 'lte_band': 2,
+ 'lte_bandwidth': 'BW20',
+ 'lte_duplex_mode': 'FDD',
+ 'lte_dl_mimo_config': 1,
+ 'lte_ul_mimo_config': 1,
+ 'nr_band': band,
+ 'nr_bandwidth': 'BW100',
+ 'nr_duplex_mode': 'TDD',
+ 'nr_channel': channel,
+ 'num_dl_cells': num_dl_cells,
+ 'num_ul_cells': 1,
+ 'nr_dl_mimo_config': dl_mimo_config,
+ 'nr_ul_mimo_config': 1
+ }
+ endc_combo_config = self.generate_endc_combo_config(test_config)
+ test_name = 'test_fr2_{}_{}_{}CC_mcs{}_{}x{}'.format(
+ band, channel.lower(), num_dl_cells, nr_dl_mcs, dl_mimo_config,
+ dl_mimo_config)
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=nr_dl_mcs,
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ self.log.info(test_cases)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularLtePlusFr1PeakThroughputTest.py b/acts_tests/tests/google/cellular/performance/CellularLtePlusFr1PeakThroughputTest.py
new file mode 100644
index 0000000..b422a30
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularLtePlusFr1PeakThroughputTest.py
@@ -0,0 +1,566 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import json
+import re
+import os
+from acts import context
+from acts import base_test
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.cellular.performance.CellularThroughputBaseTest import CellularThroughputBaseTest
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+
+from functools import partial
+
+LONG_SLEEP = 10
+MEDIUM_SLEEP = 2
+IPERF_TIMEOUT = 10
+SHORT_SLEEP = 1
+SUBFRAME_LENGTH = 0.001
+STOP_COUNTER_LIMIT = 3
+
+
+class CellularLtePlusFr1PeakThroughputTest(CellularThroughputBaseTest):
+ """Base class to test cellular LTE and FR1 throughput
+
+ This class implements cellular LTE & FR1 throughput tests on a callbox setup.
+ The class setups up the callbox in the desired configurations, configures
+ and connects the phone, and runs traffic/iperf throughput.
+ """
+
+ def process_testcase_results(self):
+ """Publish test case metrics and save results"""
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+ testcase_result = testcase_data['results'][0]
+ metric_map = {
+ 'tcp_udp_tput': testcase_result.get('iperf_throughput',
+ float('nan'))
+ }
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'nr_cell_count']:
+ metric_map.update({
+ 'nr_min_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']['min_tput'],
+ 'nr_max_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']['max_tput'],
+ 'nr_avg_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']
+ ['average_tput'],
+ 'nr_theoretical_dl_tput':
+ testcase_result['nr_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'nr_dl_bler':
+ testcase_result['nr_bler_result']['total']['DL']['nack_ratio']
+ * 100,
+ 'nr_min_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']['min_tput'],
+ 'nr_max_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']['max_tput'],
+ 'nr_avg_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']
+ ['average_tput'],
+ 'nr_theoretical_dl_tput':
+ testcase_result['nr_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'nr_ul_bler':
+ testcase_result['nr_bler_result']['total']['UL']['nack_ratio']
+ * 100
+ })
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'lte_cell_count']:
+ metric_map.update({
+ 'lte_min_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']['min_tput'],
+ 'lte_max_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']['max_tput'],
+ 'lte_avg_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']
+ ['average_tput'],
+ 'lte_theoretical_dl_tput':
+ testcase_result['lte_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'lte_dl_bler':
+ testcase_result['lte_bler_result']['total']['DL']['nack_ratio']
+ * 100,
+ 'lte_min_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']['min_tput'],
+ 'lte_max_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']['max_tput'],
+ 'lte_avg_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']
+ ['average_tput'],
+ 'lte_theoretical_dl_tput':
+ testcase_result['lte_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'lte_ul_bler':
+ testcase_result['lte_bler_result']['total']['UL']['nack_ratio']
+ * 100
+ })
+ if self.publish_testcase_metrics:
+ for metric_name, metric_value in metric_map.items():
+ self.testcase_metric_logger.add_metric(metric_name,
+ metric_value)
+
+ def process_testclass_results(self):
+ """Saves CSV with all test results to enable comparison."""
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ 'results.csv')
+ with open(results_file_path, 'w', newline='') as csvfile:
+ field_names = [
+ 'Test Name', 'NR DL Min. Throughput', 'NR DL Max. Throughput',
+ 'NR DL Avg. Throughput', 'NR DL Theoretical Throughput',
+ 'NR UL Min. Throughput', 'NR UL Max. Throughput',
+ 'NR UL Avg. Throughput', 'NR UL Theoretical Throughput',
+ 'NR DL BLER (%)', 'NR UL BLER (%)', 'LTE DL Min. Throughput',
+ 'LTE DL Max. Throughput', 'LTE DL Avg. Throughput',
+ 'LTE DL Theoretical Throughput', 'LTE UL Min. Throughput',
+ 'LTE UL Max. Throughput', 'LTE UL Avg. Throughput',
+ 'LTE UL Theoretical Throughput', 'LTE DL BLER (%)',
+ 'LTE UL BLER (%)', 'TCP/UDP Throughput'
+ ]
+ writer = csv.DictWriter(csvfile, fieldnames=field_names)
+ writer.writeheader()
+
+ for testcase_name, testcase_results in self.testclass_results.items(
+ ):
+ for result in testcase_results['results']:
+ row_dict = {
+ 'Test Name': testcase_name,
+ 'TCP/UDP Throughput':
+ result.get('iperf_throughput', 0)
+ }
+ if testcase_results['testcase_params'][
+ 'endc_combo_config']['nr_cell_count']:
+ row_dict.update({
+ 'NR DL Min. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['min_tput'],
+ 'NR DL Max. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['max_tput'],
+ 'NR DL Avg. Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['average_tput'],
+ 'NR DL Theoretical Throughput':
+ result['nr_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'NR UL Min. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['min_tput'],
+ 'NR UL Max. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['max_tput'],
+ 'NR UL Avg. Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['average_tput'],
+ 'NR UL Theoretical Throughput':
+ result['nr_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'NR DL BLER (%)':
+ result['nr_bler_result']['total']['DL']
+ ['nack_ratio'] * 100,
+ 'NR UL BLER (%)':
+ result['nr_bler_result']['total']['UL']
+ ['nack_ratio'] * 100
+ })
+ if testcase_results['testcase_params'][
+ 'endc_combo_config']['lte_cell_count']:
+ row_dict.update({
+ 'LTE DL Min. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['min_tput'],
+ 'LTE DL Max. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['max_tput'],
+ 'LTE DL Avg. Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['average_tput'],
+ 'LTE DL Theoretical Throughput':
+ result['lte_tput_result']['total']['DL']
+ ['theoretical_tput'],
+ 'LTE UL Min. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['min_tput'],
+ 'LTE UL Max. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['max_tput'],
+ 'LTE UL Avg. Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['average_tput'],
+ 'LTE UL Theoretical Throughput':
+ result['lte_tput_result']['total']['UL']
+ ['theoretical_tput'],
+ 'LTE DL BLER (%)':
+ result['lte_bler_result']['total']['DL']
+ ['nack_ratio'] * 100,
+ 'LTE UL BLER (%)':
+ result['lte_bler_result']['total']['UL']
+ ['nack_ratio'] * 100
+ })
+ writer.writerow(row_dict)
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ """Function to get per cell power sweep lists
+
+ Args:
+ testcase_params: dict containing all test case params
+ Returns:
+ cell_power_sweeps: list of cell power sweeps for each cell under test
+ """
+ cell_power_sweeps = []
+ for cell in testcase_params['endc_combo_config']['cell_list']:
+ if cell['cell_type'] == 'LTE':
+ sweep = [self.testclass_params['lte_cell_power']]
+ else:
+ sweep = [self.testclass_params['nr_cell_power']]
+ cell_power_sweeps.append(sweep)
+ return cell_power_sweeps
+
+
+class CellularLteFr1EndcPeakThroughputTest(CellularLtePlusFr1PeakThroughputTest
+ ):
+ """Class to test cellular LTE/FR1 ENDC combo list"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases([(27, 4), (4, 27)],
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs_table='QAM256',
+ transform_precoding=0)
+
+ def generate_endc_combo_config(self, endc_combo_str):
+ """Function to generate ENDC combo config from combo string
+
+ Args:
+ endc_combo_str: ENDC combo descriptor (e.g. B48A[4];A[1]+N5A[2];A[1])
+ Returns:
+ endc_combo_config: dictionary with all ENDC combo settings
+ """
+ endc_combo_str = endc_combo_str.replace(' ', '')
+ endc_combo_list = endc_combo_str.split('+')
+ endc_combo_list = [combo.split(';') for combo in endc_combo_list]
+ endc_combo_config = collections.OrderedDict()
+ cell_config_list = list()
+ lte_cell_count = 0
+ nr_cell_count = 0
+ lte_scc_list = []
+ nr_dl_carriers = []
+ nr_ul_carriers = []
+ lte_carriers = []
+
+ for cell in endc_combo_list:
+ cell_config = {}
+ dl_config_str = cell[0]
+ dl_config_regex = re.compile(
+ r'(?P<cell_type>[B,N])(?P<band>[0-9]+)(?P<bandwidth_class>[A-Z])\[(?P<mimo_config>[0-9])\]'
+ )
+ dl_config_match = re.match(dl_config_regex, dl_config_str)
+ if dl_config_match.group('cell_type') == 'B':
+ cell_config['cell_type'] = 'LTE'
+ lte_cell_count = lte_cell_count + 1
+ cell_config['cell_number'] = lte_cell_count
+ if cell_config['cell_number'] == 1:
+ cell_config['pcc'] = 1
+ endc_combo_config['lte_pcc'] = cell_config['cell_number']
+ else:
+ cell_config['pcc'] = 0
+ lte_scc_list.append(cell_config['cell_number'])
+ cell_config['band'] = dl_config_match.group('band')
+ cell_config['duplex_mode'] = 'FDD' if int(
+ cell_config['band']
+ ) in cputils.DUPLEX_MODE_TO_BAND_MAPPING['LTE'][
+ 'FDD'] else 'TDD'
+ cell_config['dl_mimo_config'] = 'D{nss}U{nss}'.format(
+ nss=dl_config_match.group('mimo_config'))
+ if int(dl_config_match.group('mimo_config')) == 1:
+ cell_config['transmission_mode'] = 'TM1'
+ elif int(dl_config_match.group('mimo_config')) == 2:
+ cell_config['transmission_mode'] = 'TM2'
+ else:
+ cell_config['transmission_mode'] = 'TM3'
+ lte_carriers.append(cell_config['cell_number'])
+ else:
+ cell_config['cell_type'] = 'NR5G'
+ nr_cell_count = nr_cell_count + 1
+ cell_config['cell_number'] = nr_cell_count
+ nr_dl_carriers.append(cell_config['cell_number'])
+ cell_config['band'] = 'N' + dl_config_match.group('band')
+ cell_config['duplex_mode'] = 'FDD' if cell_config[
+ 'band'] in cputils.DUPLEX_MODE_TO_BAND_MAPPING['NR5G'][
+ 'FDD'] else 'TDD'
+ cell_config['subcarrier_spacing'] = 'MU0' if cell_config[
+ 'duplex_mode'] == 'FDD' else 'MU1'
+ cell_config['dl_mimo_config'] = 'N{nss}X{nss}'.format(
+ nss=dl_config_match.group('mimo_config'))
+
+ cell_config['dl_bandwidth_class'] = dl_config_match.group(
+ 'bandwidth_class')
+ cell_config['dl_bandwidth'] = 'BW20'
+ cell_config['ul_enabled'] = len(cell) > 1
+ if cell_config['ul_enabled']:
+ ul_config_str = cell[1]
+ ul_config_regex = re.compile(
+ r'(?P<bandwidth_class>[A-Z])\[(?P<mimo_config>[0-9])\]')
+ ul_config_match = re.match(ul_config_regex, ul_config_str)
+ cell_config['ul_bandwidth_class'] = ul_config_match.group(
+ 'bandwidth_class')
+ cell_config['ul_mimo_config'] = 'N{nss}X{nss}'.format(
+ nss=ul_config_match.group('mimo_config'))
+ if cell_config['cell_type'] == 'NR5G':
+ nr_ul_carriers.append(cell_config['cell_number'])
+ cell_config_list.append(cell_config)
+ endc_combo_config['lte_cell_count'] = lte_cell_count
+ endc_combo_config['nr_cell_count'] = nr_cell_count
+ endc_combo_config['nr_dl_carriers'] = nr_dl_carriers
+ endc_combo_config['nr_ul_carriers'] = nr_ul_carriers
+ endc_combo_config['cell_list'] = cell_config_list
+ endc_combo_config['lte_scc_list'] = lte_scc_list
+ endc_combo_config['lte_carriers'] = lte_carriers
+ return endc_combo_config
+
+ def generate_test_cases(self, mcs_pair_list, **kwargs):
+ test_cases = []
+
+ with open(self.testclass_params['endc_combo_file'],
+ 'r') as endc_combos:
+ for endc_combo_str in endc_combos:
+ if endc_combo_str[0] == '#':
+ continue
+ endc_combo_config = self.generate_endc_combo_config(
+ endc_combo_str)
+ special_chars = '+[];\n'
+ for char in special_chars:
+ endc_combo_str = endc_combo_str.replace(char, '_')
+ endc_combo_str = endc_combo_str.replace('__', '_')
+ endc_combo_str = endc_combo_str.strip('_')
+ for mcs_pair in mcs_pair_list:
+ test_name = 'test_lte_fr1_endc_{}_dl_mcs{}_ul_mcs{}'.format(
+ endc_combo_str, mcs_pair[0], mcs_pair[1])
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=mcs_pair[0],
+ nr_ul_mcs=mcs_pair[1],
+ lte_dl_mcs=mcs_pair[0],
+ lte_ul_mcs=mcs_pair[1],
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
+class CellularSingleCellThroughputTest(CellularLtePlusFr1PeakThroughputTest):
+ """Base Class to test single cell LTE or LTE/FR1"""
+
+ def generate_endc_combo_config(self, test_config):
+ """Function to generate ENDC combo config from CSV test config
+
+ Args:
+ test_config: dict containing ENDC combo config from CSV
+ Returns:
+ endc_combo_config: dictionary with all ENDC combo settings
+ """
+ endc_combo_config = collections.OrderedDict()
+ lte_cell_count = 0
+ nr_cell_count = 0
+ lte_scc_list = []
+ nr_dl_carriers = []
+ nr_ul_carriers = []
+ lte_carriers = []
+
+ cell_config_list = []
+ if test_config['lte_band']:
+ lte_cell = {
+ 'cell_type':
+ 'LTE',
+ 'cell_number':
+ 1,
+ 'pcc':
+ 1,
+ 'band':
+ test_config['lte_band'],
+ 'dl_bandwidth':
+ test_config['lte_bandwidth'],
+ 'ul_enabled':
+ 1,
+ 'duplex_mode':
+ test_config['lte_duplex_mode'],
+ 'dl_mimo_config':
+ 'D{nss}U{nss}'.format(nss=test_config['lte_dl_mimo_config']),
+ 'ul_mimo_config':
+ 'D{nss}U{nss}'.format(nss=test_config['lte_ul_mimo_config'])
+ }
+ if int(test_config['lte_dl_mimo_config']) == 1:
+ lte_cell['transmission_mode'] = 'TM1'
+ elif int(test_config['lte_dl_mimo_config']) == 2:
+ lte_cell['transmission_mode'] = 'TM2'
+ else:
+ lte_cell['transmission_mode'] = 'TM3'
+ cell_config_list.append(lte_cell)
+ endc_combo_config['lte_pcc'] = 1
+ lte_cell_count = 1
+ lte_carriers = [1]
+
+ if test_config['nr_band']:
+ nr_cell = {
+ 'cell_type':
+ 'NR5G',
+ 'cell_number':
+ 1,
+ 'band':
+ test_config['nr_band'],
+ 'duplex_mode':
+ test_config['nr_duplex_mode'],
+ 'dl_mimo_config':
+ 'N{nss}X{nss}'.format(nss=test_config['nr_dl_mimo_config']),
+ 'dl_bandwidth_class':
+ 'A',
+ 'dl_bandwidth':
+ test_config['nr_bandwidth'],
+ 'ul_enabled':
+ 1,
+ 'ul_bandwidth_class':
+ 'A',
+ 'ul_mimo_config':
+ 'N{nss}X{nss}'.format(nss=test_config['nr_ul_mimo_config']),
+ 'subcarrier_spacing':
+ 'MU0' if test_config['nr_scs'] == '15' else 'MU1'
+ }
+ cell_config_list.append(nr_cell)
+ nr_cell_count = 1
+ nr_dl_carriers = [1]
+ nr_ul_carriers = [1]
+
+ endc_combo_config['lte_cell_count'] = lte_cell_count
+ endc_combo_config['nr_cell_count'] = nr_cell_count
+ endc_combo_config['nr_dl_carriers'] = nr_dl_carriers
+ endc_combo_config['nr_ul_carriers'] = nr_ul_carriers
+ endc_combo_config['cell_list'] = cell_config_list
+ endc_combo_config['lte_scc_list'] = lte_scc_list
+ endc_combo_config['lte_carriers'] = lte_carriers
+ return endc_combo_config
+
+
+class CellularFr1SingleCellPeakThroughputTest(CellularSingleCellThroughputTest
+ ):
+ """Class to test single cell FR1 NSA mode"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(
+ nr_mcs_pair_list=[(27, 4), (4, 27)],
+ nr_channel_list=['LOW', 'MID', 'HIGH'],
+ transform_precoding=0,
+ lte_dl_mcs=4,
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ lte_ul_mcs_table='QAM64')
+
+ def generate_test_cases(self, nr_mcs_pair_list, nr_channel_list, **kwargs):
+
+ test_cases = []
+ with open(self.testclass_params['nr_single_cell_configs'],
+ 'r') as csvfile:
+ test_configs = csv.DictReader(csvfile)
+ for test_config, nr_channel, nr_mcs_pair in itertools.product(
+ test_configs, nr_channel_list, nr_mcs_pair_list):
+ if int(test_config['skip_test']):
+ continue
+ endc_combo_config = self.generate_endc_combo_config(
+ test_config)
+ endc_combo_config['cell_list'][1]['channel'] = nr_channel
+ test_name = 'test_fr1_{}_{}_dl_mcs{}_ul_mcs{}'.format(
+ test_config['nr_band'], nr_channel.lower(), nr_mcs_pair[0],
+ nr_mcs_pair[1])
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ nr_dl_mcs=nr_mcs_pair[0],
+ nr_ul_mcs=nr_mcs_pair[1],
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
+class CellularLteSingleCellPeakThroughputTest(CellularSingleCellThroughputTest
+ ):
+ """Class to test single cell LTE"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['throughput_test_params']
+ self.tests = self.generate_test_cases(lte_mcs_pair_list=[
+ (('QAM256', 27), ('QAM256', 4)), (('QAM256', 4), ('QAM256', 27))
+ ],
+ transform_precoding=0)
+
+ def generate_test_cases(self, lte_mcs_pair_list, **kwargs):
+ test_cases = []
+ with open(self.testclass_params['lte_single_cell_configs'],
+ 'r') as csvfile:
+ test_configs = csv.DictReader(csvfile)
+ for test_config, lte_mcs_pair in itertools.product(
+ test_configs, lte_mcs_pair_list):
+ if int(test_config['skip_test']):
+ continue
+ endc_combo_config = self.generate_endc_combo_config(
+ test_config)
+ test_name = 'test_lte_B{}_dl_{}_mcs{}_ul_{}_mcs{}'.format(
+ test_config['lte_band'], lte_mcs_pair[0][0],
+ lte_mcs_pair[0][1], lte_mcs_pair[1][0], lte_mcs_pair[1][1])
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ lte_dl_mcs_table=lte_mcs_pair[0][0],
+ lte_dl_mcs=lte_mcs_pair[0][1],
+ lte_ul_mcs_table=lte_mcs_pair[1][0],
+ lte_ul_mcs=lte_mcs_pair[1][1],
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularLteSensitivityTest.py b/acts_tests/tests/google/cellular/performance/CellularLteSensitivityTest.py
new file mode 100644
index 0000000..5e27bca
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularLteSensitivityTest.py
@@ -0,0 +1,232 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import csv
+import itertools
+import numpy
+import json
+import re
+import os
+from acts import context
+from acts import base_test
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure import BokehFigure
+from CellularLtePlusFr1PeakThroughputTest import CellularLteSingleCellPeakThroughputTest
+
+from functools import partial
+
+
+class CellularLteSensitivityTest(CellularLteSingleCellPeakThroughputTest):
+ """Class to test single cell LTE sensitivity"""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.testclass_params = self.user_params['lte_sensitivity_test_params']
+ self.tests = self.generate_test_cases(dl_mcs_list=list(
+ numpy.arange(27, -1, -1)),
+ lte_dl_mcs_table='QAM256',
+ lte_ul_mcs_table='QAM256',
+ lte_ul_mcs=4,
+ transform_precoding=0)
+
+ def process_testclass_results(self):
+ # Plot individual test id results raw data and compile metrics
+ plots = collections.OrderedDict()
+ compiled_data = collections.OrderedDict()
+ for testcase_name, testcase_data in self.testclass_results.items():
+ cell_config = testcase_data['testcase_params'][
+ 'endc_combo_config']['cell_list'][0]
+ test_id = tuple(('band', cell_config['band']))
+ if test_id not in plots:
+ # Initialize test id data when not present
+ compiled_data[test_id] = {
+ 'mcs': [],
+ 'average_throughput': [],
+ 'theoretical_throughput': [],
+ 'cell_power': [],
+ }
+ plots[test_id] = BokehFigure(
+ title='Band {} ({}) - BLER Curves'.format(
+ cell_config['band'],
+ testcase_data['testcase_params']['lte_dl_mcs_table']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='BLER (Mbps)')
+ test_id_rvr = test_id + tuple('RvR')
+ plots[test_id_rvr] = BokehFigure(
+ title='Band {} ({}) - RvR'.format(
+ cell_config['band'],
+ testcase_data['testcase_params']['lte_dl_mcs_table']),
+ x_label='Cell Power (dBm)',
+ primary_y_label='PHY Rate (Mbps)')
+ # Compile test id data and metrics
+ compiled_data[test_id]['average_throughput'].append(
+ testcase_data['average_throughput_list'])
+ compiled_data[test_id]['cell_power'].append(
+ testcase_data['cell_power_list'])
+ compiled_data[test_id]['mcs'].append(
+ testcase_data['testcase_params']['lte_dl_mcs'])
+ # Add test id to plots
+ plots[test_id].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['bler_list'],
+ 'MCS {}'.format(
+ testcase_data['testcase_params']['lte_dl_mcs']),
+ width=1)
+ plots[test_id_rvr].add_line(
+ testcase_data['cell_power_list'],
+ testcase_data['average_throughput_list'],
+ 'MCS {}'.format(
+ testcase_data['testcase_params']['lte_dl_mcs']),
+ width=1,
+ style='dashed')
+
+ # Compute average RvRs and compute metrics over orientations
+ for test_id, test_data in compiled_data.items():
+ test_id_rvr = test_id + tuple('RvR')
+ cell_power_interp = sorted(set(sum(test_data['cell_power'], [])))
+ average_throughput_interp = []
+ for mcs, cell_power, throughput in zip(
+ test_data['mcs'], test_data['cell_power'],
+ test_data['average_throughput']):
+ throughput_interp = numpy.interp(cell_power_interp,
+ cell_power[::-1],
+ throughput[::-1])
+ average_throughput_interp.append(throughput_interp)
+ rvr = numpy.max(average_throughput_interp, 0)
+ plots[test_id_rvr].add_line(cell_power_interp, rvr,
+ 'Rate vs. Range')
+
+ figure_list = []
+ for plot_id, plot in plots.items():
+ plot.generate_figure()
+ figure_list.append(plot)
+ output_file_path = os.path.join(self.log_path, 'results.html')
+ BokehFigure.save_figures(figure_list, output_file_path)
+
+ def process_testcase_results(self):
+ if self.current_test_name not in self.testclass_results:
+ return
+ testcase_data = self.testclass_results[self.current_test_name]
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(testcase_data),
+ results_file,
+ indent=4)
+
+ bler_list = []
+ average_throughput_list = []
+ theoretical_throughput_list = []
+ cell_power_list = testcase_data['testcase_params']['cell_power_sweep'][
+ 0]
+ for result in testcase_data['results']:
+ bler_list.append(
+ result['lte_bler_result']['total']['DL']['nack_ratio'])
+ average_throughput_list.append(
+ result['lte_tput_result']['total']['DL']['average_tput'])
+ theoretical_throughput_list.append(
+ result['lte_tput_result']['total']['DL']['theoretical_tput'])
+ padding_len = len(cell_power_list) - len(average_throughput_list)
+ average_throughput_list.extend([0] * padding_len)
+ theoretical_throughput_list.extend([0] * padding_len)
+
+ bler_above_threshold = [
+ bler > self.testclass_params['bler_threshold']
+ for bler in bler_list
+ ]
+ for idx in range(len(bler_above_threshold)):
+ if all(bler_above_threshold[idx:]):
+ sensitivity_idx = max(idx, 1) - 1
+ break
+ else:
+ sensitivity_idx = -1
+ sensitivity = cell_power_list[sensitivity_idx]
+ self.log.info('LTE Band {} Table {} MCS {} Sensitivity = {}dBm'.format(
+ testcase_data['testcase_params']['endc_combo_config']['cell_list']
+ [0]['band'], testcase_data['testcase_params']['lte_dl_mcs_table'],
+ testcase_data['testcase_params']['lte_dl_mcs'], sensitivity))
+
+ testcase_data['bler_list'] = bler_list
+ testcase_data['average_throughput_list'] = average_throughput_list
+ testcase_data[
+ 'theoretical_throughput_list'] = theoretical_throughput_list
+ testcase_data['cell_power_list'] = cell_power_list
+ testcase_data['sensitivity'] = sensitivity
+
+ def get_per_cell_power_sweeps(self, testcase_params):
+ # get reference test
+ current_band = testcase_params['endc_combo_config']['cell_list'][0][
+ 'band']
+ reference_test = None
+ reference_sensitivity = None
+ for testcase_name, testcase_data in self.testclass_results.items():
+ if testcase_data['testcase_params']['endc_combo_config'][
+ 'cell_list'][0]['band'] == current_band:
+ reference_test = testcase_name
+ reference_sensitivity = testcase_data['sensitivity']
+ if reference_test and reference_sensitivity and not self.retry_flag:
+ start_atten = reference_sensitivity + self.testclass_params[
+ 'adjacent_mcs_gap']
+ self.log.info(
+ "Reference test {} found. Sensitivity {} dBm. Starting at {} dBm"
+ .format(reference_test, reference_sensitivity, start_atten))
+ else:
+ start_atten = self.testclass_params['lte_cell_power_start']
+ self.log.info(
+ "Reference test not found. Starting at {} dBm".format(
+ start_atten))
+ # get current cell power start
+ cell_power_sweeps = [
+ list(
+ numpy.arange(start_atten,
+ self.testclass_params['lte_cell_power_stop'],
+ self.testclass_params['lte_cell_power_step']))
+ ]
+ return cell_power_sweeps
+
+ def generate_test_cases(self, dl_mcs_list, lte_dl_mcs_table,
+ lte_ul_mcs_table, lte_ul_mcs, **kwargs):
+ test_cases = []
+ with open(self.testclass_params['lte_single_cell_configs'],
+ 'r') as csvfile:
+ test_configs = csv.DictReader(csvfile)
+ for test_config, lte_dl_mcs in itertools.product(
+ test_configs, dl_mcs_list):
+ if int(test_config['skip_test']):
+ continue
+ endc_combo_config = self.generate_endc_combo_config(
+ test_config)
+ test_name = 'test_lte_B{}_dl_{}_mcs{}'.format(
+ test_config['lte_band'], lte_dl_mcs_table, lte_dl_mcs)
+ test_params = collections.OrderedDict(
+ endc_combo_config=endc_combo_config,
+ lte_dl_mcs_table=lte_dl_mcs_table,
+ lte_dl_mcs=lte_dl_mcs,
+ lte_ul_mcs_table=lte_ul_mcs_table,
+ lte_ul_mcs=lte_ul_mcs,
+ **kwargs)
+ setattr(self, test_name,
+ partial(self._test_throughput_bler, test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/CellularRxPowerTest.py b/acts_tests/tests/google/cellular/performance/CellularRxPowerTest.py
new file mode 100644
index 0000000..9615c91
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/CellularRxPowerTest.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2022 - 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 collections
+import itertools
+import json
+import numpy
+import os
+import time
+from acts import asserts
+from acts import context
+from acts import base_test
+from acts import utils
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.cellular.keysight_5g_testapp import Keysight5GTestApp
+from acts_contrib.test_utils.cellular.performance import cellular_performance_test_utils as cputils
+from acts_contrib.test_utils.cellular.performance.shannon_log_parser import ShannonLogger
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure import BokehFigure
+from functools import partial
+
+
+class CellularRxPowerTest(base_test.BaseTestClass):
+ """Class to test cellular throughput."""
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.tests = self.generate_test_cases(['N257', 'N258', 'N260', 'N261'],
+ list(range(1, 9)))
+
+ def setup_class(self):
+ """Initializes common test hardware and parameters.
+
+ This function initializes hardwares and compiles parameters that are
+ common to all tests in this class.
+ """
+ self.dut = self.android_devices[-1]
+ self.testclass_params = self.user_params['rx_power_params']
+ self.keysight_test_app = Keysight5GTestApp(
+ self.user_params['Keysight5GTestApp'])
+ self.sdm_logger = ShannonLogger(self.dut)
+ self.testclass_results = collections.OrderedDict()
+ # Configure test retries
+ self.user_params['retry_tests'] = [self.__class__.__name__]
+
+ # Turn Airplane mode on
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+
+ def teardown_class(self):
+ self.log.info('Turning airplane mode on')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ self.keysight_test_app.set_cell_state('LTE', 1, 0)
+ self.keysight_test_app.destroy()
+
+ def setup_test(self):
+ cputils.start_pixel_logger(self.dut)
+
+ def on_retry(self):
+ """Function to control test logic on retried tests.
+
+ This function is automatically executed on tests that are being
+ retried. In this case the function resets wifi, toggles it off and on
+ and sets a retry_flag to enable further tweaking the test logic on
+ second attempts.
+ """
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ if self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE off.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 0)
+
+ def teardown_test(self):
+ self.log.info('Turning airplane mode on')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ log_path = os.path.join(
+ context.get_current_context().get_full_output_path(), 'pixel_logs')
+ os.makedirs(log_path, exist_ok=True)
+ self.log.info(self.current_test_info)
+ self.testclass_results.setdefault(self.current_test_name,
+ collections.OrderedDict())
+ self.testclass_results[self.current_test_name].setdefault(
+ 'log_path', [])
+ self.testclass_results[self.current_test_name]['log_path'].append(
+ cputils.stop_pixel_logger(self.dut, log_path))
+ self.process_test_results()
+
+ def process_test_results(self):
+ test_result = self.testclass_results[self.current_test_name]
+
+ # Save output as text file
+ results_file_path = os.path.join(
+ self.log_path, '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(test_result),
+ results_file,
+ indent=4)
+ # Plot and save
+ if test_result['log_path']:
+ log_data = self.sdm_logger.process_log(test_result['log_path'][-1])
+ else:
+ return
+ figure = BokehFigure(title=self.current_test_name,
+ x_label='Cell Power Setting (dBm)',
+ primary_y_label='Time')
+ figure.add_line(log_data.lte.rsrp_time, log_data.lte.rsrp_rx0,
+ 'LTE RSRP (Rx0)')
+ figure.add_line(log_data.lte.rsrp_time, log_data.lte.rsrp_rx1,
+ 'LTE RSRP (Rx1)')
+ figure.add_line(log_data.lte.rsrp2_time, log_data.lte.rsrp2_rx0,
+ 'LTE RSRP2 (Rx0)')
+ figure.add_line(log_data.lte.rsrp2_time, log_data.lte.rsrp2_rx1,
+ 'LTE RSRP2 (Rx0)')
+ figure.add_line(log_data.nr.rsrp_time, log_data.nr.rsrp_rx0,
+ 'NR RSRP (Rx0)')
+ figure.add_line(log_data.nr.rsrp_time, log_data.nr.rsrp_rx1,
+ 'NR RSRP (Rx1)')
+ figure.add_line(log_data.nr.rsrp2_time, log_data.nr.rsrp2_rx0,
+ 'NR RSRP2 (Rx0)')
+ figure.add_line(log_data.nr.rsrp2_time, log_data.nr.rsrp2_rx1,
+ 'NR RSRP2 (Rx0)')
+ figure.add_line(log_data.fr2.rsrp0_time, log_data.fr2.rsrp0,
+ 'NR RSRP (Rx0)')
+ figure.add_line(log_data.fr2.rsrp1_time, log_data.fr2.rsrp1,
+ 'NR RSRP2 (Rx1)')
+ output_file_path = os.path.join(
+ self.log_path, '{}.html'.format(self.current_test_name))
+ figure.generate_figure(output_file_path)
+
+ def _test_nr_rsrp(self, testcase_params):
+ """Test function to run cellular RSRP tests.
+
+ The function runs a sweep of cell powers while collecting pixel logs
+ for later postprocessing and RSRP analysis.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ """
+
+ result = collections.OrderedDict()
+ testcase_params['power_range_vector'] = list(
+ numpy.arange(self.testclass_params['cell_power_start'],
+ self.testclass_params['cell_power_stop'],
+ self.testclass_params['cell_power_step']))
+
+ if not self.keysight_test_app.get_cell_state('LTE', 'CELL1'):
+ self.log.info('Turning LTE on.')
+ self.keysight_test_app.set_cell_state('LTE', 'CELL1', 1)
+ self.log.info('Turning off airplane mode')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, False),
+ 'Can not turn on airplane mode.')
+
+ for cell in testcase_params['dl_cell_list']:
+ self.keysight_test_app.set_cell_band('NR5G', cell,
+ testcase_params['band'])
+ # Consider configuring schedule quick config
+ self.keysight_test_app.set_nr_cell_schedule_scenario(
+ testcase_params['dl_cell_list'][0], 'BASIC')
+ self.keysight_test_app.set_dl_carriers(testcase_params['dl_cell_list'])
+ self.keysight_test_app.set_ul_carriers(
+ testcase_params['dl_cell_list'][0])
+ self.log.info('Waiting for LTE and applying aggregation')
+ if not self.keysight_test_app.wait_for_cell_status(
+ 'LTE', 'CELL1', 'CONN', 60):
+ asserts.fail('DUT did not connect to LTE.')
+ self.keysight_test_app.apply_carrier_agg()
+ self.log.info('Waiting for 5G connection')
+ connected = self.keysight_test_app.wait_for_cell_status(
+ 'NR5G', testcase_params['dl_cell_list'][-1], ['ACT', 'CONN'], 60)
+ if not connected:
+ asserts.fail('DUT did not connect to NR.')
+ for cell_power in testcase_params['power_range_vector']:
+ self.log.info('Setting power to {} dBm'.format(cell_power))
+ for cell in testcase_params['dl_cell_list']:
+ self.keysight_test_app.set_cell_dl_power(
+ 'NR5G', cell, cell_power, True)
+ #measure RSRP
+ self.keysight_test_app.start_nr_rsrp_measurement(
+ testcase_params['dl_cell_list'],
+ self.testclass_params['rsrp_measurement_duration'])
+ time.sleep(self.testclass_params['rsrp_measurement_duration'] *
+ 1.5 / 1000)
+ self.keysight_test_app.get_nr_rsrp_measurement_state(
+ testcase_params['dl_cell_list'])
+ self.keysight_test_app.get_nr_rsrp_measurement_results(
+ testcase_params['dl_cell_list'])
+
+ for cell in testcase_params['dl_cell_list'][::-1]:
+ self.keysight_test_app.set_cell_state('NR5G', cell, 0)
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ # Save results
+ result['testcase_params'] = testcase_params
+ self.testclass_results[self.current_test_name] = result
+ results_file_path = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '{}.json'.format(self.current_test_name))
+ with open(results_file_path, 'w') as results_file:
+ json.dump(wputils.serialize_dict(result), results_file, indent=4)
+
+ def generate_test_cases(self, bands, num_cells_list):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+
+ for band, num_cells in itertools.product(bands, num_cells_list):
+ test_name = 'test_nr_rsrp_{}_{}CC'.format(band, num_cells)
+ test_params = collections.OrderedDict(band=band,
+ num_cells=num_cells,
+ dl_cell_list=list(
+ range(1, num_cells + 1)))
+ setattr(self, test_name, partial(self._test_nr_rsrp, test_params))
+ test_cases.append(test_name)
+ return test_cases
diff --git a/acts_tests/tests/google/cellular/performance/__init__.py b/acts_tests/tests/google/cellular/performance/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts_tests/tests/google/cellular/performance/__init__.py
diff --git a/acts_tests/tests/google/gnss/FlpTtffTest.py b/acts_tests/tests/google/gnss/FlpTtffTest.py
index 0a30fe8..2d1f194 100644
--- a/acts_tests/tests/google/gnss/FlpTtffTest.py
+++ b/acts_tests/tests/google/gnss/FlpTtffTest.py
@@ -17,7 +17,6 @@
from acts import asserts
from acts import signals
from acts.base_test import BaseTestClass
-from acts.test_decorators import test_tracker_info
from acts.utils import get_current_epoch_time
from acts_contrib.test_utils.wifi.wifi_test_utils import wifi_toggle_state
from acts_contrib.test_utils.tel.tel_logging_utils import start_qxdm_logger
@@ -40,6 +39,8 @@
from acts_contrib.test_utils.gnss.gnss_test_utils import connect_to_wifi_network
from acts_contrib.test_utils.gnss.gnss_test_utils import gnss_tracking_via_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import parse_gtw_gpstool_log
+from acts_contrib.test_utils.gnss.gnss_test_utils import log_current_epoch_time
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
class FlpTtffTest(BaseTestClass):
@@ -63,6 +64,8 @@
_init_device(self.ad)
def setup_test(self):
+ log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
get_baseband_and_gms_version(self.ad)
if self.collect_logs:
clear_logd_gnss_qxdm_log(self.ad)
@@ -85,6 +88,7 @@
set_wifi_and_bt_scanning(self.ad, True)
if self.ad.droid.wifiCheckState():
wifi_toggle_state(self.ad, False)
+ log_current_epoch_time(self.ad, "test_end_time")
def on_pass(self, test_name, begin_time):
if self.collect_logs:
@@ -106,11 +110,11 @@
for mode in ttff.keys():
begin_time = get_current_epoch_time()
process_gnss_by_gtw_gpstool(
- self.ad, self.standalone_cs_criteria, type="flp")
+ self.ad, self.standalone_cs_criteria, api_type="flp")
start_ttff_by_gtw_gpstool(
self.ad, ttff_mode=mode, iteration=self.ttff_test_cycle)
ttff_data = process_ttff_by_gtw_gpstool(
- self.ad, begin_time, location, type="flp")
+ self.ad, begin_time, location, api_type="flp")
result = check_ttff_data(self.ad, ttff_data, ttff[mode], criteria)
flp_results.append(result)
asserts.assert_true(
@@ -124,7 +128,6 @@
""" Test Cases """
- @test_tracker_info(uuid="c11ada6a-d7ad-4dc8-9d4a-0ae3cb9dfa8e")
def test_flp_one_hour_tracking(self):
"""Verify FLP tracking performance of position error.
@@ -137,10 +140,9 @@
"""
self.start_qxdm_and_tcpdump_log()
gnss_tracking_via_gtw_gpstool(self.ad, self.standalone_cs_criteria,
- type="flp", testtime=60)
- parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, type="flp")
+ api_type="flp", testtime=60)
+ parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="flp")
- @test_tracker_info(uuid="8bc4e82d-fdce-4ee8-af8c-5e4a925b5360")
def test_flp_ttff_strong_signal_wifiscan_on_wifi_connect(self):
"""Verify FLP TTFF Hot Start and Cold Start under strong GNSS signals
with WiFi scanning on and connected.
@@ -163,7 +165,6 @@
self.flp_ttff_hs_and_cs(self.flp_ttff_max_threshold,
self.pixel_lab_location)
- @test_tracker_info(uuid="adc1a0c7-3635-420d-9481-0f5816c58334")
def test_flp_ttff_strong_signal_wifiscan_on_wifi_not_connect(self):
"""Verify FLP TTFF Hot Start and Cold Start under strong GNSS signals
with WiFi scanning on and not connected.
@@ -183,7 +184,6 @@
self.flp_ttff_hs_and_cs(self.flp_ttff_max_threshold,
self.pixel_lab_location)
- @test_tracker_info(uuid="3ec3cee2-b881-4c61-9df1-b6b81fcd4527")
def test_flp_ttff_strong_signal_wifiscan_off(self):
"""Verify FLP TTFF Hot Start and Cold Start with WiFi scanning OFF
under strong GNSS signals.
@@ -202,7 +202,6 @@
self.flp_ttff_hs_and_cs(self.flp_ttff_max_threshold,
self.pixel_lab_location)
- @test_tracker_info(uuid="03c0d34f-8312-48d5-8753-93b09151233a")
def test_flp_ttff_weak_signal_wifiscan_on_wifi_connect(self):
"""Verify FLP TTFF Hot Start and Cold Start under Weak GNSS signals
with WiFi scanning on and connected
@@ -228,7 +227,6 @@
self.flp_ttff_hs_and_cs(self.flp_ttff_max_threshold,
self.pixel_lab_location)
- @test_tracker_info(uuid="13daf7b3-5ac5-4107-b3dc-a3a8b5589fed")
def test_flp_ttff_weak_signal_wifiscan_on_wifi_not_connect(self):
"""Verify FLP TTFF Hot Start and Cold Start under Weak GNSS signals
with WiFi scanning on and not connected.
@@ -251,7 +249,6 @@
self.flp_ttff_hs_and_cs(self.flp_ttff_max_threshold,
self.pixel_lab_location)
- @test_tracker_info(uuid="1831f80f-099f-46d2-b484-f332046d5a4d")
def test_flp_ttff_weak_signal_wifiscan_off(self):
"""Verify FLP TTFF Hot Start and Cold Start with WiFi scanning OFF
under weak GNSS signals.
diff --git a/acts_tests/tests/google/gnss/GnssBlankingThTest.py b/acts_tests/tests/google/gnss/GnssBlankingThTest.py
index e625171..171a453 100644
--- a/acts_tests/tests/google/gnss/GnssBlankingThTest.py
+++ b/acts_tests/tests/google/gnss/GnssBlankingThTest.py
@@ -28,12 +28,14 @@
first_wait = self.user_params.get('first_wait', 300)
# Start the test item with gnss_init_power_setting.
- if self.gnss_init_power_setting(first_wait):
- self.log.info('Successfully set the GNSS power level to %d' %
- self.sa_sensitivity)
+ ret, pwr_lvl = self.gnss_init_power_setting(first_wait)
+ if ret:
+ self.log.info(f'Successfully set the GNSS power level to {pwr_lvl}')
self.log.info('Start searching for cellular power level threshold')
# After the GNSS power initialization is done, start the cellular power sweep.
self.result_cell_pwr = self.cell_power_sweep()
+ else:
+ raise AttributeError('Init power sweep is missing')
def test_gnss_gsm850_sweep(self):
"""
diff --git a/acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py b/acts_tests/tests/google/gnss/GnssBroadcomConfigurationTest.py
similarity index 88%
rename from acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py
rename to acts_tests/tests/google/gnss/GnssBroadcomConfigurationTest.py
index 9f3ccfd..64fe9c8 100644
--- a/acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py
+++ b/acts_tests/tests/google/gnss/GnssBroadcomConfigurationTest.py
@@ -8,6 +8,7 @@
For more details, please refer to : go/p22_user_build_verification
"""
import os
+import re
import shutil
import tempfile
import time
@@ -15,9 +16,10 @@
from acts import asserts
from acts import signals
from acts.base_test import BaseTestClass
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
from acts.controllers.adb_lib.error import AdbCommandError
from acts.libs.proc.job import TimeoutError
-from acts.test_decorators import test_tracker_info
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
@@ -147,7 +149,6 @@
self.lheconsole = "LheConsole"
self.lheconsole_hub = self.get_lheconsole_value()
self.esw_crash_dump_pattern = self.get_esw_crash_dump_pattern()
- self.ad.log.info(f"here is {self.esw_crash_dump_pattern}")
def _adjust_lhe_setting(self, key, enable):
"""Set lhe setting.
@@ -251,14 +252,16 @@
return False
-class GnssUserBuildBroadcomConfigurationTest(BaseTestClass):
- """ GNSS user build configuration Tests on Broadcom device."""
+class GnssBroadcomConfigurationTest(BaseTestClass):
+ """ GNSS configuration Tests on Broadcom device."""
def setup_class(self):
super().setup_class()
self.ad = self.android_devices[0]
+ req_params = ["standalone_cs_criteria"]
+ self.unpack_userparams(req_param_names=req_params)
if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
- gutils._init_device(self.ad)
+ self.init_device()
self.gps_config_path = tempfile.mkdtemp()
self.gps_xml = GpsXml(self.ad)
self.lhd_conf = LhdConf(self.ad)
@@ -266,19 +269,31 @@
self.enable_testing_setting()
self.backup_gps_config()
+ def init_device(self):
+ gutils._init_device(self.ad)
+ gutils.enable_supl_mode(self.ad)
+ gutils.enable_vendor_orbit_assistance_data(self.ad)
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.set_mobile_data(self.ad, state=True)
+
+
def teardown_class(self):
if hasattr(self, "gps_config_path") and os.path.isdir(self.gps_config_path):
shutil.rmtree(self.gps_config_path)
def setup_test(self):
+ gutils.log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
if gutils.check_chipset_vendor_by_qualcomm(self.ad):
raise signals.TestSkip("Device is Qualcomm, skip the test")
+ gutils.get_baseband_and_gms_version(self.ad)
gutils.clear_logd_gnss_qxdm_log(self.ad)
def teardown_test(self):
if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
self.revert_gps_config()
self.ad.reboot()
+ gutils.log_current_epoch_time(self.ad, "test_end_time")
def on_fail(self, test_name, begin_time):
self.ad.take_bug_report(test_name, begin_time)
@@ -317,10 +332,7 @@
def run_gps_and_capture_log(self):
"""Enable GPS via gps tool for 15s and capture pixel log"""
gutils.start_pixel_logger(self.ad)
- gutils.start_gnss_by_gtw_gpstool(self.ad, state=True)
- time.sleep(15)
- gutils.start_gnss_by_gtw_gpstool(self.ad, state=False)
- gutils.stop_pixel_logger(self.ad)
+ gutils.gnss_tracking_via_gtw_gpstool(self.ad, self.standalone_cs_criteria, testtime=1)
def set_gps_logenabled(self, enable):
"""Set LogEnabled in gps.xml / lhd.conf / scd.conf
@@ -337,44 +349,50 @@
self.scd_conf.disable_diagnostic_log()
self.lhd_conf.disable_diagnostic_log()
- @test_tracker_info(uuid="1dd68d9c-38b0-4fbc-8635-1228c72872ff")
def test_gps_logenabled_setting(self):
"""Verify the LogEnabled setting in gps.xml / scd.conf / lhd.conf
Steps:
1. default setting is on in user_debug build
- 2. enable gps for 15s
- 3. assert gps log pattern "slog :" in pixel logger
+ 2. run gps tracking for 1 min
+ 3. should find slog in pixel logger log files
4. disable LogEnabled in all the gps conf
- 5. enable gps for 15s
- 6. assert gps log pattern "slog :" in pixel logger
+ 5. run gps tracking for 1 min
+ 6. should not find slog in pixel logger log files
"""
self.run_gps_and_capture_log()
- result, _ = gutils.parse_brcm_nmea_log(self.ad, "slog :", [])
+ pattern = re.compile(f".*slog\s+:.*")
+ result, _ = gutils.parse_brcm_nmea_log(self.ad, pattern, [])
asserts.assert_true(bool(result), "LogEnabled is set to true, but no gps log was found")
self.set_gps_logenabled(enable=False)
gutils.clear_logd_gnss_qxdm_log(self.ad)
+ # Removes pixel logger path again in case pixel logger still writes log unexpectedly.
+ gutils.remove_pixel_logger_folder(self.ad)
self.run_gps_and_capture_log()
- result, _ = gutils.parse_brcm_nmea_log(self.ad, "slog :", [])
- asserts.assert_false(bool(result), ("LogEnabled is set to False but still found %d slog",
- len(result)))
+ try:
+ result, _ = gutils.parse_brcm_nmea_log(self.ad, pattern, [])
+ asserts.assert_false(
+ bool(result),
+ ("LogEnabled is set to False but still found %d slog" % len(result)))
+ except FileNotFoundError:
+ self.ad.log.info("Test pass because no BRCM log files/folders was found")
- @test_tracker_info(uuid="152a12e0-7957-47e0-9ea7-14725254fd1d")
def test_gps_supllogenable_setting(self):
"""Verify SuplLogEnable in gps.xml
Steps:
1. default setting is on in user_debug build
2. remove existing supl log
- 3. enable gps for 15s
+ 3. run gps tracking for 1 min
4. supl log should exist
5. disable SuplLogEnable in gps.xml
6. remove existing supl log
- 7. enable gps for 15s
+ 7. run gps tracking for 1 min
8. supl log should not exist
"""
def is_supl_log_exist_after_supl_request():
self.gps_xml.remove_supl_logs()
+ self.ad.reboot()
self.run_gps_and_capture_log()
return self.gps_xml.is_supl_log_file_exist()
@@ -382,12 +400,10 @@
asserts.assert_true(result, "SuplLogEnable is enable, should find supl log file")
self.gps_xml.disable_supl_log()
- self.ad.reboot()
result = is_supl_log_exist_after_supl_request()
asserts.assert_false(result, "SuplLogEnable is disable, should not find supl log file")
- @test_tracker_info(uuid="892d0037-8c0c-45b6-bd0f-9e4073d37232")
def test_lhe_setting(self):
"""Verify lhefailsafe / lheconsole setting in lhd.conf
Steps:
diff --git a/acts_tests/tests/google/gnss/GnssConcurrencyTest.py b/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
index 9169f4e..3cbb2a7 100644
--- a/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
+++ b/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
@@ -15,15 +15,17 @@
# limitations under the License.
import time
-import datetime
import re
+import statistics
+from datetime import datetime
from acts import utils
from acts import signals
from acts.base_test import BaseTestClass
-from acts.test_decorators import test_tracker_info
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
from acts_contrib.test_utils.tel.tel_logging_utils import start_adb_tcpdump
from acts_contrib.test_utils.tel.tel_logging_utils import stop_adb_tcpdump
from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log
+from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode
from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
CONCURRENCY_TYPE = {
@@ -32,6 +34,24 @@
"ap_location": "reportLocation"
}
+GPS_XML_CONFIG = {
+ "CS": [
+ ' IgnorePosition=\"true\"\n', ' IgnoreEph=\"true\"\n',
+ ' IgnoreTime=\"true\"\n', ' AsstIgnoreLto=\"true\"\n',
+ ' IgnoreJniTime=\"true\"\n'
+ ],
+ "WS": [
+ ' IgnorePosition=\"true\"\n', ' AsstIgnoreLto=\"true\"\n',
+ ' IgnoreJniTime=\"true\"\n'
+ ],
+ "HS": []
+}
+
+ONCHIP_CONFIG = [
+ ' EnableOnChipStopNotification=\"1\"\n',
+ ' EnableOnChipStopNotification=\"2\"\n'
+]
+
class GnssConcurrencyTest(BaseTestClass):
""" GNSS Concurrency TTFF Tests. """
@@ -42,15 +62,16 @@
req_params = [
"standalone_cs_criteria", "chre_tolerate_rate", "qdsp6m_path",
"outlier_criteria", "max_outliers", "pixel_lab_location",
- "max_interval", "onchip_interval"
+ "max_interval", "onchip_interval", "ttff_test_cycle"
]
self.unpack_userparams(req_param_names=req_params)
gutils._init_device(self.ad)
self.ad.adb.shell("setprop persist.vendor.radio.adb_log_on 0")
self.ad.adb.shell("sync")
- gutils.reboot(self.ad)
def setup_test(self):
+ gutils.log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
gutils.clear_logd_gnss_qxdm_log(self.ad)
gutils.start_pixel_logger(self.ad)
start_adb_tcpdump(self.ad)
@@ -62,6 +83,7 @@
def teardown_test(self):
gutils.stop_pixel_logger(self.ad)
stop_adb_tcpdump(self.ad)
+ gutils.log_current_epoch_time(self.ad, "test_end_time")
def on_fail(self, test_name, begin_time):
self.ad.take_bug_report(test_name, begin_time)
@@ -78,8 +100,12 @@
for _ in range(0, 3):
try:
self.ad.log.info("Start to load the nanoapp")
- res = self.ad.adb.shell("chre_power_test_client load")
- if "success: 1" in res:
+ cmd = "chre_power_test_client load"
+ if gutils.is_device_wearable(self.ad):
+ extra_cmd = "tcm /vendor/etc/chre/power_test_tcm.so"
+ cmd = " ".join([cmd, extra_cmd])
+ res = self.ad.adb.shell(cmd)
+ if "result 1" in res:
self.ad.log.info("Nano app loaded successfully")
break
except Exception as e:
@@ -88,65 +114,79 @@
else:
raise signals.TestError("Failed to load CHRE nanoapp")
- def enable_chre(self, freq):
+ def enable_chre(self, interval_sec):
""" Enable or disable gnss concurrency via nanoapp.
Args:
- freq: an int for frequency, set 0 as disable.
+ interval_sec: an int for frequency, set 0 as disable.
"""
- freq = freq * 1000
+ if interval_sec == 0:
+ self.ad.log.info(f"Stop CHRE request")
+ else:
+ self.ad.log.info(
+ f"Initiate CHRE with {interval_sec} seconds interval")
+ interval_msec = interval_sec * 1000
cmd = "chre_power_test_client"
- option = "enable %d" % freq if freq != 0 else "disable"
+ option = "enable %d" % interval_msec if interval_msec != 0 else "disable"
for type in CONCURRENCY_TYPE.keys():
if "ap" not in type:
self.ad.adb.shell(" ".join([cmd, type, option]))
- def parse_concurrency_result(self, begin_time, type, criteria):
+ def parse_concurrency_result(self,
+ begin_time,
+ request_type,
+ criteria,
+ exam_lower=True):
""" Parse the test result with given time and criteria.
Args:
begin_time: test begin time.
- type: str for location request type.
+ request_type: str for location request type.
criteria: dictionary for test criteria.
+ exam_lower: a boolean to identify the lower bond or not.
Return: List for the failure and outlier loops and results.
"""
results = []
failures = []
outliers = []
- search_results = self.ad.search_logcat(CONCURRENCY_TYPE[type],
+ upper_bound = criteria * (
+ 1 + self.chre_tolerate_rate) + self.outlier_criteria
+ lower_bound = criteria * (
+ 1 - self.chre_tolerate_rate) - self.outlier_criteria
+ search_results = self.ad.search_logcat(CONCURRENCY_TYPE[request_type],
begin_time)
- start_time = utils.epoch_to_human_time(begin_time)
- start_time = datetime.datetime.strptime(start_time,
- "%m-%d-%Y %H:%M:%S ")
if not search_results:
raise signals.TestFailure(f"No log entry found for keyword:"
- f"{CONCURRENCY_TYPE[type]}")
- results.append(
- (search_results[0]["datetime_obj"] - start_time).total_seconds())
- samples = len(search_results) - 1
- for i in range(samples):
+ f"{CONCURRENCY_TYPE[request_type]}")
+
+ for i in range(len(search_results) - 1):
target = search_results[i + 1]
timedelt = target["datetime_obj"] - search_results[i]["datetime_obj"]
timedelt_sec = timedelt.total_seconds()
results.append(timedelt_sec)
- if timedelt_sec > (criteria *
- self.chre_tolerate_rate) + self.outlier_criteria:
- failures.append(target)
- self.ad.log.error("[Failure][%s]:%.2f sec" %
- (target["time_stamp"], timedelt_sec))
- elif timedelt_sec > criteria * self.chre_tolerate_rate:
- outliers.append(target)
- self.ad.log.info("[Outlier][%s]:%.2f sec" %
- (target["time_stamp"], timedelt_sec))
+ res_tag = ""
+ if timedelt_sec > upper_bound:
+ failures.append(timedelt_sec)
+ res_tag = "Failure"
+ elif timedelt_sec < lower_bound and exam_lower:
+ failures.append(timedelt_sec)
+ res_tag = "Failure"
+ elif timedelt_sec > criteria * (1 + self.chre_tolerate_rate):
+ outliers.append(timedelt_sec)
+ res_tag = "Outlier"
+ if res_tag:
+ self.ad.log.error(
+ f"[{res_tag}][{target['time_stamp']}]:{timedelt_sec:.2f} sec"
+ )
- res_summary = " ".join([str(res) for res in results])
- self.ad.log.info("[%s]Overall Result: %s" % (type, res_summary))
- self.ad.log.info("TestResult %s_samples %d" % (type, samples))
- self.ad.log.info("TestResult %s_outliers %d" % (type, len(outliers)))
- self.ad.log.info("TestResult %s_failures %d" % (type, len(failures)))
- self.ad.log.info("TestResult %s_max_time %.2f" %
- (type, max(results[1:])))
+ res_summary = " ".join([str(res) for res in results[1:]])
+ self.ad.log.info(f"[{request_type}]Overall Result: {res_summary}")
+ log_prefix = f"TestResult {request_type}"
+ self.ad.log.info(f"{log_prefix}_samples {len(search_results)}")
+ self.ad.log.info(f"{log_prefix}_outliers {len(outliers)}")
+ self.ad.log.info(f"{log_prefix}_failures {len(failures)}")
+ self.ad.log.info(f"{log_prefix}_max_time {max(results):.2f}")
return outliers, failures, results
@@ -157,12 +197,14 @@
criteria: int for test criteria.
test_duration: int for test duration.
"""
- begin_time = utils.get_current_epoch_time()
- self.ad.log.info("Tests Start at %s" %
- utils.epoch_to_human_time(begin_time))
- gutils.start_gnss_by_gtw_gpstool(
- self.ad, True, freq=criteria["ap_location"])
self.enable_chre(criteria["gnss"])
+ TTFF_criteria = criteria["ap_location"] + self.standalone_cs_criteria
+ gutils.process_gnss_by_gtw_gpstool(
+ self.ad, TTFF_criteria, freq=criteria["ap_location"])
+ self.ad.log.info("Tracking 10 sec to prevent flakiness.")
+ time.sleep(10)
+ begin_time = datetime.now()
+ self.ad.log.info(f"Test Start at {begin_time}")
time.sleep(test_duration)
self.enable_chre(0)
gutils.start_gnss_by_gtw_gpstool(self.ad, False)
@@ -175,9 +217,8 @@
criteria: int for test criteria.
test_duration: int for test duration.
"""
- begin_time = utils.get_current_epoch_time()
- self.ad.log.info("Tests Start at %s" %
- utils.epoch_to_human_time(begin_time))
+ begin_time = datetime.now()
+ self.ad.log.info(f"Test Start at {begin_time}")
self.enable_chre(criteria["gnss"])
time.sleep(test_duration)
self.enable_chre(0)
@@ -199,12 +240,12 @@
self.ad.log.info("Starting process %s result" % request_type)
outliers[request_type], failures[request_type], results[
request_type] = self.parse_concurrency_result(
- begin_time, request_type, criteria)
+ begin_time, request_type, criteria, exam_lower=False)
if not results[request_type]:
failure_log += "[%s] Fail to find location report.\n" % request_type
if len(failures[request_type]) > 0:
- failure_log += "[%s] Test exceeds criteria: %.2f\n" % (
- request_type, criteria)
+ failure_log += "[%s] Test exceeds criteria(%.2f): %.2f\n" % (
+ request_type, criteria, max(failures[request_type]))
if len(outliers[request_type]) > self.max_outliers:
failure_log += "[%s] Outliers excceds max amount: %d\n" % (
request_type, len(outliers[request_type]))
@@ -219,7 +260,7 @@
freq: a list identify source1/2 frequency [freq1, freq2]
"""
request = {"ap_location": self.max_interval}
- begin_time = utils.get_current_epoch_time()
+ begin_time = datetime.now()
self.ad.droid.startLocating(freq[0] * 1000, 0)
time.sleep(10)
for i in range(5):
@@ -253,73 +294,183 @@
self.ad.log.info("TestResult max_position_error %.2f" %
max(position_errors))
+ def get_chre_ttff(self, interval_sec, duration):
+ """ Get the TTFF for the first CHRE report.
+
+ Args:
+ interval_sec: test interval in seconds for CHRE.
+ duration: test duration.
+ """
+ begin_time = datetime.now()
+ self.ad.log.info(f"Test start at {begin_time}")
+ self.enable_chre(interval_sec)
+ time.sleep(duration)
+ self.enable_chre(0)
+ for type, pattern in CONCURRENCY_TYPE.items():
+ if type == "ap_location":
+ continue
+ search_results = self.ad.search_logcat(pattern, begin_time)
+ if not search_results:
+ raise signals.TestFailure(
+ f"Unable to receive {type} report in {duration} seconds")
+ else:
+ ttff_stamp = search_results[0]["datetime_obj"]
+ self.ad.log.info(search_results[0]["time_stamp"])
+ ttff = (ttff_stamp - begin_time).total_seconds()
+ self.ad.log.info(f"CHRE {type} TTFF = {ttff}")
+
+ def add_ttff_conf(self, conf_type):
+ """ Add mcu ttff config to gps.xml
+
+ Args:
+ conf_type: a string identify the config type
+ """
+ search_line_tag = "<gll\n"
+ append_line_str = GPS_XML_CONFIG[conf_type]
+ gutils.bcm_gps_xml_update_option(self.ad, "add", search_line_tag,
+ append_line_str)
+
+ def update_gps_conf(self, search_line, update_line):
+ """ Update gps.xml content
+
+ Args:
+ search_line: target content
+ update_line: update content
+ """
+ gutils.bcm_gps_xml_update_option(
+ self.ad, "update", search_line, update_txt=update_line)
+
+ def delete_gps_conf(self, conf_type):
+ """ Delete gps.xml content
+
+ Args:
+ conf_type: a string identify the config type
+ """
+ search_line_tag = GPS_XML_CONFIG[conf_type]
+ gutils.bcm_gps_xml_update_option(
+ self.ad, "delete", delete_txt=search_line_tag)
+
+ def preset_mcu_test(self, mode):
+ """ Preseting mcu test with config and device state
+
+ mode:
+ mode: a string identify the test type
+ """
+ self.add_ttff_conf(mode)
+ gutils.push_lhd_overlay(self.ad)
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=True)
+ self.update_gps_conf(ONCHIP_CONFIG[1], ONCHIP_CONFIG[0])
+ gutils.clear_aiding_data_by_gtw_gpstool(self.ad)
+ self.ad.reboot(self.ad)
+ self.load_chre_nanoapp()
+
+ def reset_mcu_test(self, mode):
+ """ Resetting mcu test with config and device state
+
+ mode:
+ mode: a string identify the test type
+ """
+ self.delete_gps_conf(mode)
+ self.update_gps_conf(ONCHIP_CONFIG[0], ONCHIP_CONFIG[1])
+
+ def get_mcu_ttff(self):
+ """ Get mcu ttff seconds
+
+ Return:
+ ttff: a float identify ttff seconds
+ """
+ search_res = ""
+ search_pattern = "$PGLOR,0,FIX"
+ ttff_regex = r"FIX,(.*)\*"
+ cmd_base = "chre_power_test_client gnss tcm"
+ cmd_start = " ".join([cmd_base, "enable 1000"])
+ cmd_stop = " ".join([cmd_base, "disable"])
+ begin_time = datetime.now()
+
+ self.ad.log.info("Send CHRE enable to DUT")
+ self.ad.adb.shell(cmd_start)
+ for i in range(6):
+ search_res = self.ad.search_logcat(search_pattern, begin_time)
+ if search_res:
+ break
+ time.sleep(10)
+ else:
+ self.ad.adb.shell(cmd_stop)
+ self.ad.log.error("Unable to get mcu ttff in 60 seconds")
+ return 60
+ self.ad.adb.shell(cmd_stop)
+
+ res = re.search(ttff_regex, search_res[0]["log_message"])
+ ttff = res.group(1)
+ self.ad.log.info(f"TTFF = {ttff}")
+ return float(ttff)
+
+ def run_mcu_ttff_loops(self, mode, loops):
+ """ Run mcu ttff with given mode and loops
+
+ Args:
+ mode: a string identify mode cs/ws/hs.
+ loops: a int to identify the number of loops
+ """
+ ttff_res = []
+ for i in range(10):
+ ttff = self.get_mcu_ttff()
+ self.ad.log.info(f"{mode} TTFF LOOP{i+1} = {ttff}")
+ ttff_res.append(ttff)
+ time.sleep(10)
+ self.ad.log.info(f"TestResult {mode}_MAX_TTFF {max(ttff_res)}")
+ self.ad.log.info(
+ f"TestResult {mode}_AVG_TTFF {statistics.mean(ttff_res)}")
+
# Concurrency Test Cases
- @test_tracker_info(uuid="9b0daebf-461e-4005-9773-d5d10aaeaaa4")
- def test_gnss_concurrency_ct1(self):
+ def test_gnss_concurrency_location_1_chre_1(self):
test_duration = 15
criteria = {"ap_location": 1, "gnss": 1, "gnss_meas": 1}
self.run_gnss_concurrency_test(criteria, test_duration)
- @test_tracker_info(uuid="f423db2f-12a0-4858-b66f-99e7ca6010c3")
- def test_gnss_concurrency_ct2(self):
+ def test_gnss_concurrency_location_1_chre_8(self):
test_duration = 30
criteria = {"ap_location": 1, "gnss": 8, "gnss_meas": 8}
self.run_gnss_concurrency_test(criteria, test_duration)
- @test_tracker_info(uuid="f72d2df0-f70a-4a11-9f68-2a38f6974454")
- def test_gnss_concurrency_ct3(self):
+ def test_gnss_concurrency_location_15_chre_8(self):
test_duration = 60
criteria = {"ap_location": 15, "gnss": 8, "gnss_meas": 8}
self.run_gnss_concurrency_test(criteria, test_duration)
- @test_tracker_info(uuid="8e5563fd-afcd-40d3-9392-7fc0d10f49da")
- def test_gnss_concurrency_aoc1(self):
+ def test_gnss_concurrency_location_61_chre_1(self):
test_duration = 120
criteria = {"ap_location": 61, "gnss": 1, "gnss_meas": 1}
self.run_gnss_concurrency_test(criteria, test_duration)
- @test_tracker_info(uuid="fb258565-6ac8-4bf7-a554-01d63fc4ef54")
- def test_gnss_concurrency_aoc2(self):
+ def test_gnss_concurrency_location_61_chre_10(self):
test_duration = 120
criteria = {"ap_location": 61, "gnss": 10, "gnss_meas": 10}
self.run_gnss_concurrency_test(criteria, test_duration)
# CHRE Only Test Cases
- @test_tracker_info(uuid="cb85fa60-9f1a-4957-b5e3-0f2e5db70b47")
- def test_gnss_chre1(self):
+ def test_gnss_chre_1(self):
test_duration = 15
criteria = {"gnss": 1, "gnss_meas": 1}
self.run_chre_only_test(criteria, test_duration)
- @test_tracker_info(uuid="6ab17866-0d0e-4d9e-b3af-441d9db0e324")
- def test_gnss_chre2(self):
+ def test_gnss_chre_8(self):
test_duration = 30
criteria = {"gnss": 8, "gnss_meas": 8}
self.run_chre_only_test(criteria, test_duration)
# Interval tests
- @test_tracker_info(uuid="53b161e5-335e-44a7-ae2e-eae7464a2b37")
def test_variable_interval_via_chre(self):
test_duration = 10
- intervals = [{
- "gnss": 0.1,
- "gnss_meas": 0.1
- }, {
- "gnss": 0.5,
- "gnss_meas": 0.5
- }, {
- "gnss": 1.5,
- "gnss_meas": 1.5
- }]
+ intervals = [0.1, 0.5, 1.5]
for interval in intervals:
- self.run_chre_only_test(interval, test_duration)
+ self.get_chre_ttff(interval, test_duration)
- @test_tracker_info(uuid="ee0a46fe-aa5f-4dfd-9cb7-d4924f9e9cea")
def test_variable_interval_via_framework(self):
test_duration = 10
intervals = [0, 0.5, 1.5]
for interval in intervals:
- begin_time = utils.get_current_epoch_time()
+ begin_time = datetime.now()
self.ad.droid.startLocating(interval * 1000, 0)
time.sleep(test_duration)
self.ad.droid.stopLocating()
@@ -327,14 +478,30 @@
self.parse_concurrency_result(begin_time, "ap_location", criteria)
# Engine switching test
- @test_tracker_info(uuid="8b42bcb2-cb8c-4ef9-bd98-4fb74a521224")
def test_gps_engine_switching_host_to_onchip(self):
self.is_brcm_test()
freq = [1, self.onchip_interval]
self.run_engine_switching_test(freq)
- @test_tracker_info(uuid="636041dc-2bd6-4854-aa5d-61c87943d99c")
def test_gps_engine_switching_onchip_to_host(self):
self.is_brcm_test()
freq = [self.onchip_interval, 1]
self.run_engine_switching_test(freq)
+
+ def test_mcu_cs_ttff(self):
+ mode = "CS"
+ self.preset_mcu_test(mode)
+ self.run_mcu_ttff_loops(mode, self.ttff_test_cycle)
+ self.reset_mcu_test(mode)
+
+ def test_mcu_ws_ttff(self):
+ mode = "WS"
+ self.preset_mcu_test(mode)
+ self.run_mcu_ttff_loops(mode, self.ttff_test_cycle)
+ self.reset_mcu_test(mode)
+
+ def test_mcu_hs_ttff(self):
+ mode = "HS"
+ self.preset_mcu_test(mode)
+ self.run_mcu_ttff_loops(mode, self.ttff_test_cycle)
+ self.reset_mcu_test(mode)
diff --git a/acts_tests/tests/google/gnss/GnssFunctionTest.py b/acts_tests/tests/google/gnss/GnssFunctionTest.py
index d45a997..b22cd4f 100644
--- a/acts_tests/tests/google/gnss/GnssFunctionTest.py
+++ b/acts_tests/tests/google/gnss/GnssFunctionTest.py
@@ -13,18 +13,14 @@
# 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 os
import re
import fnmatch
-from multiprocessing import Process
from acts import asserts
from acts import signals
from acts.base_test import BaseTestClass
-from acts.test_decorators import test_tracker_info
-from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
-from acts_contrib.test_utils.tel import tel_test_utils as tutils
from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
from acts.utils import get_current_epoch_time
from acts.utils import unzip_maintain_permissions
@@ -32,9 +28,8 @@
from acts_contrib.test_utils.tel.tel_bootloader_utils import flash_radio
from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection
from acts_contrib.test_utils.tel.tel_test_utils import check_call_state_connected_by_adb
-from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call
+from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode
from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
-from acts_contrib.test_utils.tel.tel_data_utils import http_file_download_by_sl4a
from acts_contrib.test_utils.gnss.gnss_test_utils import get_baseband_and_gms_version
from acts_contrib.test_utils.gnss.gnss_test_utils import set_attenuator_gnss_signal
from acts_contrib.test_utils.gnss.gnss_test_utils import _init_device
@@ -49,28 +44,18 @@
from acts_contrib.test_utils.gnss.gnss_test_utils import launch_google_map
from acts_contrib.test_utils.gnss.gnss_test_utils import check_location_api
from acts_contrib.test_utils.gnss.gnss_test_utils import set_battery_saver_mode
-from acts_contrib.test_utils.gnss.gnss_test_utils import kill_xtra_daemon
from acts_contrib.test_utils.gnss.gnss_test_utils import start_gnss_by_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import process_gnss_by_gtw_gpstool
-from acts_contrib.test_utils.gnss.gnss_test_utils import start_ttff_by_gtw_gpstool
-from acts_contrib.test_utils.gnss.gnss_test_utils import process_ttff_by_gtw_gpstool
-from acts_contrib.test_utils.gnss.gnss_test_utils import check_ttff_data
-from acts_contrib.test_utils.gnss.gnss_test_utils import start_youtube_video
-from acts_contrib.test_utils.gnss.gnss_test_utils import fastboot_factory_reset
-from acts_contrib.test_utils.gnss.gnss_test_utils import gnss_trigger_modem_ssr_by_mds
-from acts_contrib.test_utils.gnss.gnss_test_utils import disable_supl_mode
from acts_contrib.test_utils.gnss.gnss_test_utils import connect_to_wifi_network
-from acts_contrib.test_utils.gnss.gnss_test_utils import check_xtra_download
from acts_contrib.test_utils.gnss.gnss_test_utils import gnss_tracking_via_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import parse_gtw_gpstool_log
-from acts_contrib.test_utils.gnss.gnss_test_utils import enable_supl_mode
from acts_contrib.test_utils.gnss.gnss_test_utils import start_toggle_gnss_by_gtw_gpstool
from acts_contrib.test_utils.gnss.gnss_test_utils import grant_location_permission
from acts_contrib.test_utils.gnss.gnss_test_utils import is_mobile_data_on
from acts_contrib.test_utils.gnss.gnss_test_utils import is_wearable_btwifi
-from acts_contrib.test_utils.gnss.gnss_test_utils import delete_lto_file
from acts_contrib.test_utils.gnss.gnss_test_utils import is_device_wearable
-from acts_contrib.test_utils.tel.tel_logging_utils import start_adb_tcpdump
+from acts_contrib.test_utils.gnss.gnss_test_utils import log_current_epoch_time
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
from acts_contrib.test_utils.tel.tel_logging_utils import stop_adb_tcpdump
from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log
@@ -80,25 +65,20 @@
def setup_class(self):
super().setup_class()
self.ad = self.android_devices[0]
- req_params = ["pixel_lab_network", "standalone_cs_criteria",
+ req_params = ["pixel_lab_network",
"standalone_ws_criteria", "standalone_hs_criteria",
- "supl_cs_criteria", "supl_ws_criteria",
- "supl_hs_criteria", "xtra_cs_criteria",
- "xtra_ws_criteria", "xtra_hs_criteria",
- "weak_signal_supl_cs_criteria",
- "weak_signal_supl_ws_criteria",
- "weak_signal_supl_hs_criteria",
- "weak_signal_xtra_cs_criteria",
- "weak_signal_xtra_ws_criteria",
- "weak_signal_xtra_hs_criteria",
+ "supl_cs_criteria",
+ "supl_hs_criteria",
+ "standalone_cs_criteria",
"wearable_reboot_hs_criteria",
"default_gnss_signal_attenuation",
"weak_gnss_signal_attenuation",
- "no_gnss_signal_attenuation", "gnss_init_error_list",
+ "gnss_init_error_list",
"gnss_init_error_allowlist", "pixel_lab_location",
- "qdsp6m_path", "supl_capabilities", "ttff_test_cycle",
+ "qdsp6m_path", "ttff_test_cycle",
"collect_logs", "dpo_threshold",
- "brcm_error_log_allowlist"]
+ "brcm_error_log_allowlist", "onchip_interval", "adr_ratio_threshold",
+ "set_attenuator", "weak_signal_criteria", "weak_signal_cs_criteria"]
self.unpack_userparams(req_param_names=req_params)
# create hashmap for SSID
self.ssid_map = {}
@@ -109,23 +89,35 @@
"ws": "Warm Start",
"hs": "Hot Start",
"csa": "CSWith Assist"}
- if self.collect_logs and \
- gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ if self.collect_logs and gutils.check_chipset_vendor_by_qualcomm(self.ad):
self.flash_new_radio_or_mbn()
self.push_gnss_cfg()
- _init_device(self.ad)
+ self.init_device()
+
+ def init_device(self):
+ gutils._init_device(self.ad)
+ gutils.enable_supl_mode(self.ad)
+ gutils.enable_vendor_orbit_assistance_data(self.ad)
+ gutils.disable_ramdump(self.ad)
def setup_test(self):
+ log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
get_baseband_and_gms_version(self.ad)
if self.collect_logs:
clear_logd_gnss_qxdm_log(self.ad)
+ if self.set_attenuator:
set_attenuator_gnss_signal(self.ad, self.attenuators,
self.default_gnss_signal_attenuation)
# TODO (b/202101058:chenstanley): Need to double check how to disable wifi successfully in wearable projects.
if is_wearable_btwifi(self.ad):
wifi_toggle_state(self.ad, True)
connect_to_wifi_network(
- self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+ self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+ else:
+ wifi_toggle_state(self.ad, False)
+ set_mobile_data(self.ad, True)
+
if not verify_internet_connection(self.ad.log, self.ad, retries=3,
expected_state=True):
raise signals.TestFailure("Fail to connect to LTE network.")
@@ -134,6 +126,7 @@
if self.collect_logs:
gutils.stop_pixel_logger(self.ad)
stop_adb_tcpdump(self.ad)
+ if self.set_attenuator:
set_attenuator_gnss_signal(self.ad, self.attenuators,
self.default_gnss_signal_attenuation)
# TODO(chenstanley): sim structure issue
@@ -142,17 +135,11 @@
hangup_call(self.ad.log, self.ad)
if self.ad.droid.connectivityCheckAirplaneMode():
self.ad.log.info("Force airplane mode off")
- self.ad.droid.connectivityToggleAirplaneMode(False)
- if not is_wearable_btwifi and self.ad.droid.wifiCheckState():
- wifi_toggle_state(self.ad, False)
- if not is_mobile_data_on(self.ad):
- set_mobile_data(self.ad, True)
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=False)
if int(self.ad.adb.shell(
"settings get global wifi_scan_always_enabled")) != 1:
set_wifi_and_bt_scanning(self.ad, True)
- if not verify_internet_connection(self.ad.log, self.ad, retries=3,
- expected_state=True):
- raise signals.TestFailure("Fail to connect to LTE network.")
+ log_current_epoch_time(self.ad, "test_end_time")
def on_fail(self, test_name, begin_time):
if self.collect_logs:
@@ -248,41 +235,6 @@
self.ad.log.error("cat mcfg.version with error %s", e)
return False
- def run_ttff_via_gtw_gpstool(self, mode, criteria):
- """Run GNSS TTFF test with selected mode and parse the results.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the TTFF.
- """
- begin_time = get_current_epoch_time()
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(self.ad, mode, self.ttff_test_cycle)
- ttff_data = process_ttff_by_gtw_gpstool(
- self.ad, begin_time, self.pixel_lab_location)
- result = check_ttff_data(
- self.ad, ttff_data, self.ttff_mode.get(mode), criteria)
- asserts.assert_true(
- result, "TTFF %s fails to reach designated criteria of %d "
- "seconds." % (self.ttff_mode.get(mode), criteria))
-
- def start_qxdm_and_tcpdump_log(self):
- """Start QXDM and adb tcpdump if collect_logs is True."""
- if self.collect_logs:
- gutils.start_pixel_logger(self.ad)
- start_adb_tcpdump(self.ad)
-
- def supl_ttff_with_sim(self, mode, criteria):
- """Verify SUPL TTFF functionality.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the test.
- """
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
def standalone_ttff_airplane_mode_on(self, mode, criteria):
"""Verify Standalone GNSS TTFF functionality while airplane mode is on.
@@ -290,92 +242,79 @@
mode: "cs", "ws" or "hs"
criteria: Criteria for the test.
"""
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
self.ad.log.info("Turn airplane mode on")
- self.ad.droid.connectivityToggleAirplaneMode(True)
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
- def supl_ttff_weak_gnss_signal(self, mode, criteria):
- """Verify SUPL TTFF functionality under weak GNSS signal.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the test.
- """
- set_attenuator_gnss_signal(self.ad, self.attenuators,
- self.weak_gnss_signal_attenuation)
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
- def xtra_ttff_mobile_data(self, mode, criteria):
- """Verify XTRA\LTO TTFF functionality with mobile data.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the test.
- """
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
- def xtra_ttff_weak_gnss_signal(self, mode, criteria):
- """Verify XTRA\LTO TTFF functionality under weak GNSS signal.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the test.
- """
- set_attenuator_gnss_signal(self.ad, self.attenuators,
- self.weak_gnss_signal_attenuation)
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
- def xtra_ttff_wifi(self, mode, criteria):
- """Verify XTRA\LTO TTFF functionality with WiFi.
-
- Args:
- mode: "cs", "ws" or "hs"
- criteria: Criteria for the test.
- """
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.ad.log.info("Turn airplane mode on")
- self.ad.droid.connectivityToggleAirplaneMode(True)
- wifi_toggle_state(self.ad, True)
- connect_to_wifi_network(
- self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
- self.run_ttff_via_gtw_gpstool(mode, criteria)
-
- def ttff_with_assist(self, mode, criteria):
- """Verify CS/WS TTFF functionality with Assist data.
-
- Args:
- mode: "csa" or "ws"
- criteria: Criteria for the test.
- """
- disable_supl_mode(self.ad)
- begin_time = get_current_epoch_time()
- process_gnss_by_gtw_gpstool(
- self.ad, self.standalone_cs_criteria)
- check_xtra_download(self.ad, begin_time)
- self.ad.log.info("Turn airplane mode on")
- self.ad.droid.connectivityToggleAirplaneMode(True)
- start_gnss_by_gtw_gpstool(self.ad, True)
- start_ttff_by_gtw_gpstool(
- self.ad, mode, iteration=self.ttff_test_cycle)
- ttff_data = process_ttff_by_gtw_gpstool(
- self.ad, begin_time, self.pixel_lab_location)
- result = check_ttff_data(
- self.ad, ttff_data, mode, criteria)
- asserts.assert_true(
- result, "TTFF %s fails to reach designated criteria of %d "
- "seconds." % (self.ttff_mode.get(mode), criteria))
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=True)
+ gutils.run_ttff_via_gtw_gpstool(
+ self.ad, mode, criteria, self.ttff_test_cycle, self.pixel_lab_location)
""" Test Cases """
- @test_tracker_info(uuid="ab859f2a-2c95-4d15-bb7f-bd0e3278340f")
+ def test_cs_first_fixed_system_server_restart(self):
+ """Verify cs first fixed after system server restart.
+
+ Steps:
+ 1. Get location fixed within supl_cs_criteria.
+ 2. Restarts android runtime.
+ 3. Get location fixed within supl_cs_criteria.
+
+ Expected Results:
+ Location fixed within supl_cs_criteria.
+ """
+ overall_test_result = []
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
+ for test_loop in range(1, 6):
+ gutils.process_gnss_by_gtw_gpstool(self.ad, self.supl_cs_criteria)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ self.ad.restart_runtime()
+ self.ad.unlock_screen(password=None)
+ test_result = gutils.process_gnss_by_gtw_gpstool(self.ad, self.supl_cs_criteria)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ self.ad.log.info("Iteration %d => %s" % (test_loop, test_result))
+ overall_test_result.append(test_result)
+
+ asserts.assert_true(all(overall_test_result),
+ "SUPL fail after system server restart.")
+
+ def test_cs_ttff_after_gps_service_restart(self):
+ """Verify cs ttff after modem silent reboot / GPS daemons restart.
+
+ Steps:
+ 1. Trigger modem crash by adb/Restart GPS daemons by killing PID.
+ 2. Wait 1 minute for modem to recover.
+ 3. TTFF Cold Start for 3 iteration.
+ 4. Repeat Step 1. to Step 3. for 5 times.
+
+ Expected Results:
+ All SUPL TTFF Cold Start results should be within supl_cs_criteria.
+ """
+ supl_ssr_test_result_all = []
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
+ for times in range(1, 6):
+ begin_time = get_current_epoch_time()
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ test_info = "Modem SSR"
+ gutils.gnss_trigger_modem_ssr_by_mds(self.ad)
+ else:
+ test_info = "restarting GPS daemons"
+ gutils.restart_gps_daemons(self.ad)
+ if not verify_internet_connection(self.ad.log, self.ad, retries=3,
+ expected_state=True):
+ raise signals.TestFailure("Fail to connect to LTE network.")
+ gutils.process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
+ gutils.start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=3)
+ ttff_data = gutils.process_ttff_by_gtw_gpstool(self.ad, begin_time,
+ self.pixel_lab_location)
+ supl_ssr_test_result = gutils.check_ttff_data(
+ self.ad, ttff_data, ttff_mode="Cold Start",
+ criteria=self.supl_cs_criteria)
+ self.ad.log.info("SUPL after %s test %d times -> %s" % (
+ test_info, times, supl_ssr_test_result))
+ supl_ssr_test_result_all.append(supl_ssr_test_result)
+
+ asserts.assert_true(all(supl_ssr_test_result_all),
+ "TTFF fails to reach designated criteria")
+
def test_gnss_one_hour_tracking(self):
"""Verify GNSS tracking performance of signal strength and position
error.
@@ -387,14 +326,17 @@
Expected Results:
DUT could finish 60 minutes test and output track data.
"""
- self.start_qxdm_and_tcpdump_log()
+ test_time = 60
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
gnss_tracking_via_gtw_gpstool(self.ad, self.standalone_cs_criteria,
- type="gnss", testtime=60)
- parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, type="gnss")
+ api_type="gnss", testtime=test_time)
+ location_data = parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss")
+ gutils.validate_location_fix_rate(self.ad, location_data, run_time=test_time,
+ fix_rate_criteria=0.99)
+ gutils.verify_gps_time_should_be_close_to_device_time(self.ad, location_data)
- @test_tracker_info(uuid="623628ab-fdab-449d-9025-ebf4e9a404c2")
- def test_dpo_function(self):
- """Verify DPO Functionality.
+ def test_duty_cycle_function(self):
+ """Verify duty cycle Functionality.
Steps:
1. Launch GTW_GPSTool.
@@ -403,14 +345,14 @@
4. Calculate the count diff of "HardwareClockDiscontinuityCount"
Expected Results:
- DPO should be engaged in 5 minutes GNSS tracking.
+ Duty cycle should be engaged in 5 minutes GNSS tracking.
"""
tracking_minutes = 5
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
dpo_begin_time = get_current_epoch_time()
gnss_tracking_via_gtw_gpstool(self.ad,
self.standalone_cs_criteria,
- type="gnss",
+ api_type="gnss",
testtime=tracking_minutes,
meas_flag=True)
if gutils.check_chipset_vendor_by_qualcomm(self.ad):
@@ -422,7 +364,6 @@
self.dpo_threshold,
self.brcm_error_log_allowlist)
- @test_tracker_info(uuid="499d2091-640a-4735-9c58-de67370e4421")
def test_gnss_init_error(self):
"""Check if there is any GNSS initialization error after reboot.
@@ -452,30 +393,6 @@
asserts.assert_true(error_mismatch, "Error message found after GNSS "
"init")
- @test_tracker_info(uuid="ff318483-411c-411a-8b1a-422bd54f4a3f")
- def test_supl_capabilities(self):
- """Verify SUPL capabilities.
-
- Steps:
- 1. Root DUT.
- 2. Check SUPL capabilities.
-
- Expected Results:
- CAPABILITIES=0x37 which supports MSA + MSB.
- CAPABILITIES=0x17 = ON_DEMAND_TIME | MSA | MSB | SCHEDULING
- """
- if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
- raise signals.TestSkip("Not Qualcomm chipset. Skip the test.")
- capabilities_state = str(
- self.ad.adb.shell(
- "cat vendor/etc/gps.conf | grep CAPABILITIES")).split("=")[-1]
- self.ad.log.info("SUPL capabilities - %s" % capabilities_state)
- asserts.assert_true(capabilities_state in self.supl_capabilities,
- "Wrong default SUPL capabilities is set. Found %s, "
- "expected any of %r" % (capabilities_state,
- self.supl_capabilities))
-
- @test_tracker_info(uuid="dcae6979-ddb4-4cad-9d14-fbdd9439cf42")
def test_sap_valid_modes(self):
"""Verify SAP Valid Modes.
@@ -494,7 +411,6 @@
asserts.assert_true("SAP=PREMIUM" in sap_state,
"Wrong SAP Valid Modes is set")
- @test_tracker_info(uuid="14daaaba-35b4-42d9-8d2c-2a803dd746a6")
def test_network_location_provider_cell(self):
"""Verify LocationManagerService API reports cell Network Location.
@@ -508,7 +424,7 @@
Test devices could report cell Network Location.
"""
test_result_all = []
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
set_wifi_and_bt_scanning(self.ad, False)
for i in range(1, 6):
test_result = check_network_location(
@@ -519,7 +435,6 @@
asserts.assert_true(all(test_result_all),
"Fail to get networkLocationType=cell")
- @test_tracker_info(uuid="a45bdc7d-29fa-4a1d-ba34-6340b90e308d")
def test_network_location_provider_wifi(self):
"""Verify LocationManagerService API reports wifi Network Location.
@@ -533,7 +448,7 @@
Test devices could report wifi Network Location.
"""
test_result_all = []
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
set_wifi_and_bt_scanning(self.ad, True)
for i in range(1, 6):
test_result = check_network_location(
@@ -543,62 +458,6 @@
asserts.assert_true(all(test_result_all),
"Fail to get networkLocationType=wifi")
- @test_tracker_info(uuid="0919d375-baf2-4fe7-b66b-3f72d386f791")
- def test_gmap_location_report_gps_network(self):
- """Verify GnssLocationProvider API reports location to Google Map
- when GPS and Location Accuracy are on.
-
- Steps:
- 1. GPS and NLP are on.
- 2. Launch Google Map.
- 3. Verify whether test devices could report location.
- 4. Repeat Step 2. to Step 3. for 5 times.
-
- Expected Results:
- Test devices could report location to Google Map.
- """
- test_result_all = []
- self.start_qxdm_and_tcpdump_log()
- for i in range(1, 6):
- grant_location_permission(self.ad, True)
- launch_google_map(self.ad)
- test_result = check_location_api(self.ad, retries=3)
- self.ad.send_keycode("HOME")
- test_result_all.append(test_result)
- self.ad.log.info("Iteration %d => %s" % (i, test_result))
- asserts.assert_true(all(test_result_all), "Fail to get location update")
-
- @test_tracker_info(uuid="513361d2-7d72-41b0-a944-fb259c606b81")
- def test_gmap_location_report_gps(self):
- """Verify GnssLocationProvider API reports location to Google Map
- when GPS is on and Location Accuracy is off.
-
- Steps:
- 1. GPS is on.
- 2. Location Accuracy is off.
- 3. Launch Google Map.
- 4. Verify whether test devices could report location.
- 5. Repeat Step 3. to Step 4. for 5 times.
-
- Expected Results:
- Test devices could report location to Google Map.
- """
- test_result_all = []
- self.start_qxdm_and_tcpdump_log()
- self.ad.adb.shell("settings put secure location_mode 1")
- out = int(self.ad.adb.shell("settings get secure location_mode"))
- self.ad.log.info("Modify current Location Mode to %d" % out)
- for i in range(1, 6):
- grant_location_permission(self.ad, True)
- launch_google_map(self.ad)
- test_result = check_location_api(self.ad, retries=3)
- self.ad.send_keycode("HOME")
- test_result_all.append(test_result)
- self.ad.log.info("Iteration %d => %s" % (i, test_result))
- check_location_service(self.ad)
- asserts.assert_true(all(test_result_all), "Fail to get location update")
-
- @test_tracker_info(uuid="91a65121-b87d-450d-bd0f-387ade450ab7")
def test_gmap_location_report_battery_saver(self):
"""Verify GnssLocationProvider API reports location to Google Map
when Battery Saver is enabled.
@@ -615,7 +474,7 @@
Test devices could report location to Google Map.
"""
test_result_all = []
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
set_battery_saver_mode(self.ad, True)
for i in range(1, 6):
grant_location_permission(self.ad, True)
@@ -627,174 +486,6 @@
set_battery_saver_mode(self.ad, False)
asserts.assert_true(all(test_result_all), "Fail to get location update")
- @test_tracker_info(uuid="a59c72af-5d56-4d88-9746-ae2749cac671")
- def test_supl_ttff_cs(self):
- """Verify SUPL functionality of TTFF Cold Start.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. SUPL TTFF Cold Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be less than
- supl_cs_criteria.
- """
- self.supl_ttff_with_sim("cs", self.supl_cs_criteria)
-
- @test_tracker_info(uuid="9a91c8ad-1978-414a-a9ac-8ebc782f77ff")
- def test_supl_ttff_ws(self):
- """Verify SUPL functionality of TTFF Warm Start.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. SUPL TTFF Warm Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Warm Start results should be less than
- supl_ws_criteria.
- """
- self.supl_ttff_with_sim("ws", self.supl_ws_criteria)
-
- @test_tracker_info(uuid="bbd5aad4-3309-4579-a3b2-a06bfb674dfa")
- def test_supl_ttff_hs(self):
- """Verify SUPL functionality of TTFF Hot Start.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. SUPL TTFF Hot Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Hot Start results should be less than
- supl_hs_criteria.
- """
- self.supl_ttff_with_sim("hs", self.supl_hs_criteria)
-
- @test_tracker_info(uuid="60c0aeec-0c8f-4a96-bc6c-05cba1260e73")
- def test_supl_ongoing_call(self):
- """Verify SUPL functionality during phone call.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. Initiate call on DUT.
- 3. SUPL TTFF Cold Start for 10 iteration.
- 4. DUT hang up call.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be less than
- supl_cs_criteria.
- """
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.ad.droid.setVoiceCallVolume(25)
- initiate_call(self.ad.log, self.ad, "99117")
- time.sleep(5)
- if not check_call_state_connected_by_adb(self.ad):
- raise signals.TestFailure("Call is not connected.")
- self.run_ttff_via_gtw_gpstool("cs", self.supl_cs_criteria)
-
- @test_tracker_info(uuid="df605509-328f-43e8-b6d8-00635bf701ef")
- def test_supl_downloading_files(self):
- """Verify SUPL functionality when downloading files.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. DUT start downloading files by sl4a.
- 3. SUPL TTFF Cold Start for 10 iteration.
- 4. DUT cancel downloading files.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be within supl_cs_criteria.
- """
- begin_time = get_current_epoch_time()
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- download = Process(target=http_file_download_by_sl4a,
- args=(self.ad, "https://speed.hetzner.de/10GB.bin",
- None, None, True, 3600))
- download.start()
- time.sleep(10)
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(
- self.ad, ttff_mode="cs", iteration=self.ttff_test_cycle)
- ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
- self.pixel_lab_location)
- download.terminate()
- time.sleep(3)
- result = check_ttff_data(self.ad, ttff_data, ttff_mode="Cold Start",
- criteria=self.supl_cs_criteria)
- asserts.assert_true(result, "TTFF fails to reach designated criteria")
-
- @test_tracker_info(uuid="66b9f9d4-1397-4da7-9e55-8b89b1732017")
- def test_supl_watching_youtube(self):
- """Verify SUPL functionality when watching video on youtube.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. DUT start watching video on youtube.
- 3. SUPL TTFF Cold Start for 10 iteration at the background.
- 4. DUT stop watching video on youtube.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be within supl_cs_criteria.
- """
- begin_time = get_current_epoch_time()
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.ad.droid.setMediaVolume(25)
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(
- self.ad, ttff_mode="cs", iteration=self.ttff_test_cycle)
- start_youtube_video(self.ad,
- url="https://www.youtube.com/watch?v=AbdVsi1VjQY",
- retries=3)
- ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
- self.pixel_lab_location)
- result = check_ttff_data(self.ad, ttff_data, ttff_mode="Cold Start",
- criteria=self.supl_cs_criteria)
- asserts.assert_true(result, "TTFF fails to reach designated criteria")
-
- @test_tracker_info(uuid="a748af8b-e1eb-4ec6-bde3-74bcefa1c680")
- def test_supl_modem_ssr(self):
- """Verify SUPL functionality after modem silent reboot /
- GPS daemons restart.
-
- Steps:
- 1. Trigger modem crash by adb/Restart GPS daemons by killing PID.
- 2. Wait 1 minute for modem to recover.
- 3. SUPL TTFF Cold Start for 3 iteration.
- 4. Repeat Step 1. to Step 3. for 5 times.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be within supl_cs_criteria.
- """
- supl_ssr_test_result_all = []
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for times in range(1, 6):
- begin_time = get_current_epoch_time()
- if gutils.check_chipset_vendor_by_qualcomm(self.ad):
- test_info = "Modem SSR"
- gnss_trigger_modem_ssr_by_mds(self.ad)
- else:
- test_info = "restarting GPS daemons"
- gutils.restart_gps_daemons(self.ad)
- if not verify_internet_connection(self.ad.log, self.ad, retries=3,
- expected_state=True):
- raise signals.TestFailure("Fail to connect to LTE network.")
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=3)
- ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
- self.pixel_lab_location)
- supl_ssr_test_result = check_ttff_data(
- self.ad, ttff_data, ttff_mode="Cold Start",
- criteria=self.supl_cs_criteria)
- self.ad.log.info("SUPL after %s test %d times -> %s" % (
- test_info, times, supl_ssr_test_result))
- supl_ssr_test_result_all.append(supl_ssr_test_result)
- asserts.assert_true(all(supl_ssr_test_result_all),
- "TTFF fails to reach designated criteria")
-
- @test_tracker_info(uuid="01602e65-8ded-4459-8df1-7df70a1bfe8a")
def test_gnss_ttff_cs_airplane_mode_on(self):
"""Verify Standalone GNSS functionality of TTFF Cold Start while
airplane mode is on.
@@ -809,7 +500,6 @@
"""
self.standalone_ttff_airplane_mode_on("cs", self.standalone_cs_criteria)
- @test_tracker_info(uuid="30b9e7c2-0048-4ccd-b3ae-f385eb5f4e46")
def test_gnss_ttff_ws_airplane_mode_on(self):
"""Verify Standalone GNSS functionality of TTFF Warm Start while
airplane mode is on.
@@ -824,7 +514,6 @@
"""
self.standalone_ttff_airplane_mode_on("ws", self.standalone_ws_criteria)
- @test_tracker_info(uuid="8f3c323a-c625-4339-ab7a-6a41d34cba8f")
def test_gnss_ttff_hs_airplane_mode_on(self):
"""Verify Standalone GNSS functionality of TTFF Hot Start while
airplane mode is on.
@@ -839,372 +528,54 @@
"""
self.standalone_ttff_airplane_mode_on("hs", self.standalone_hs_criteria)
- @test_tracker_info(uuid="23731b0d-cb80-4c79-a877-cfe7c2faa447")
- def test_gnss_mobile_data_off(self):
- """Verify Standalone GNSS functionality while mobile radio is off.
-
- Steps:
- 1. Disable mobile data.
- 2. TTFF Cold Start for 10 iteration.
- 3. Enable mobile data.
-
- Expected Results:
- All Standalone TTFF Cold Start results should be within
- standalone_cs_criteria.
- """
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- set_mobile_data(self.ad, False)
- self.run_ttff_via_gtw_gpstool("cs", self.standalone_cs_criteria)
-
- @test_tracker_info(uuid="085b86a9-0212-4c0f-8ca1-2e467a0a2e6e")
- def test_supl_after_regain_gnss_signal(self):
- """Verify SUPL functionality after regain GNSS signal.
-
- Steps:
- 1. Get location fixed.
- 2 Let device do GNSS tracking for 1 minute.
- 3. Set attenuation value to block GNSS signal.
- 4. Let DUT stay in no GNSS signal for 5 minutes.
- 5. Set attenuation value to regain GNSS signal.
- 6. Try to get location reported again.
- 7. Repeat Step 1. to Step 6. for 5 times.
-
- Expected Results:
- After setting attenuation value to 10 (GPS signal regain),
- DUT could get location fixed again.
- """
- supl_no_gnss_signal_all = []
- enable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for times in range(1, 6):
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- self.ad.log.info("Let device do GNSS tracking for 1 minute.")
- time.sleep(60)
- set_attenuator_gnss_signal(self.ad, self.attenuators,
- self.no_gnss_signal_attenuation)
- self.ad.log.info("Let device stay in no GNSS signal for 5 minutes.")
- time.sleep(300)
- set_attenuator_gnss_signal(self.ad, self.attenuators,
- self.default_gnss_signal_attenuation)
- supl_no_gnss_signal = check_location_api(self.ad, retries=3)
- start_gnss_by_gtw_gpstool(self.ad, False)
- self.ad.log.info("SUPL without GNSS signal test %d times -> %s"
- % (times, supl_no_gnss_signal))
- supl_no_gnss_signal_all.append(supl_no_gnss_signal)
- asserts.assert_true(all(supl_no_gnss_signal_all),
- "Fail to get location update")
-
- @test_tracker_info(uuid="3ff2f2fa-42d8-47fa-91de-060816cca9df")
- def test_supl_ttff_cs_weak_gnss_signal(self):
- """Verify SUPL functionality of TTFF Cold Start under weak GNSS signal.
+ def test_cs_ttff_in_weak_gnss_signal(self):
+ """Verify TTFF cold start under weak GNSS signal.
Steps:
1. Set attenuation value to weak GNSS signal.
- 2. Kill XTRA/LTO daemon to support SUPL only case.
- 3. SUPL TTFF Cold Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be less than
- weak_signal_supl_cs_criteria.
- """
- self.supl_ttff_weak_gnss_signal("cs", self.weak_signal_supl_cs_criteria)
-
- @test_tracker_info(uuid="d72364d4-dad8-4d46-8190-87183def9822")
- def test_supl_ttff_ws_weak_gnss_signal(self):
- """Verify SUPL functionality of TTFF Warm Start under weak GNSS signal.
-
- Steps:
- 1. Set attenuation value to weak GNSS signal.
- 2. Kill XTRA/LTO daemon to support SUPL only case.
- 3. SUPL TTFF Warm Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Warm Start results should be less than
- weak_signal_supl_ws_criteria.
- """
- self.supl_ttff_weak_gnss_signal("ws", self.weak_signal_supl_ws_criteria)
-
- @test_tracker_info(uuid="aeb95733-9829-470d-bfc7-e3b059bf881f")
- def test_supl_ttff_hs_weak_gnss_signal(self):
- """Verify SUPL functionality of TTFF Hot Start under weak GNSS signal.
-
- Steps:
- 1. Set attenuation value to weak GNSS signal.
- 2. Kill XTRA/LTO daemon to support SUPL only case.
- 3. SUPL TTFF Hot Start for 10 iteration.
-
- Expected Results:
- All SUPL TTFF Hot Start results should be less than
- weak_signal_supl_hs_criteria.
- """
- self.supl_ttff_weak_gnss_signal("hs", self.weak_signal_supl_hs_criteria)
-
- @test_tracker_info(uuid="4ad4a371-949a-42e1-b1f4-628c79fa8ddc")
- def test_supl_factory_reset(self):
- """Verify SUPL functionality after factory reset.
-
- Steps:
- 1. Factory reset device.
- 2. Kill XTRA/LTO daemon to support SUPL only case.
- 3. SUPL TTFF Cold Start for 10 iteration.
- 4. Repeat Step 1. to Step 3. for 3 times.
-
- Expected Results:
- All SUPL TTFF Cold Start results should be within supl_cs_criteria.
- """
- for times in range(1, 4):
- fastboot_factory_reset(self.ad, True)
- self.ad.unlock_screen(password=None)
- _init_device(self.ad)
- begin_time = get_current_epoch_time()
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(
- self.ad, ttff_mode="cs", iteration=self.ttff_test_cycle)
- ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
- self.pixel_lab_location)
- if not check_ttff_data(self.ad, ttff_data, ttff_mode="Cold Start",
- criteria=self.supl_cs_criteria):
- raise signals.TestFailure("SUPL after Factory Reset test %d "
- "times -> FAIL" % times)
- self.ad.log.info("SUPL after Factory Reset test %d times -> "
- "PASS" % times)
-
- @test_tracker_info(uuid="ea3096cf-4f72-4e91-bfb3-0bcbfe865ab4")
- def test_xtra_ttff_cs_mobile_data(self):
- """Verify XTRA/LTO functionality of TTFF Cold Start with mobile data.
-
- Steps:
- 1. Disable SUPL mode.
2. TTFF Cold Start for 10 iteration.
Expected Results:
- XTRA/LTO TTFF Cold Start results should be within xtra_cs_criteria.
+ TTFF CS results should be within weak_signal_cs_criteria.
"""
- self.xtra_ttff_mobile_data("cs", self.xtra_cs_criteria)
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.weak_gnss_signal_attenuation)
+ gutils.run_ttff(self.ad, mode="cs", criteria=self.weak_signal_cs_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
- @test_tracker_info(uuid="c9b22894-deb3-4dc2-af14-4dcbb8ebad66")
- def test_xtra_ttff_ws_mobile_data(self):
- """Verify XTRA/LTO functionality of TTFF Warm Start with mobile data.
+ def test_ws_ttff_in_weak_gnss_signal(self):
+ """Verify TTFF warm start under weak GNSS signal.
Steps:
- 1. Disable SUPL mode.
- 2. TTFF Warm Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Warm Start results should be within xtra_ws_criteria.
- """
- self.xtra_ttff_mobile_data("ws", self.xtra_ws_criteria)
-
- @test_tracker_info(uuid="273741e2-0815-4817-96df-9c13401119dd")
- def test_xtra_ttff_hs_mobile_data(self):
- """Verify XTRA/LTO functionality of TTFF Hot Start with mobile data.
-
- Steps:
- 1. Disable SUPL mode.
- 2. TTFF Hot Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Hot Start results should be within xtra_hs_criteria.
- """
- self.xtra_ttff_mobile_data("hs", self.xtra_hs_criteria)
-
- @test_tracker_info(uuid="c91ba740-220e-41de-81e5-43af31f63907")
- def test_xtra_ttff_cs_weak_gnss_signal(self):
- """Verify XTRA/LTO functionality of TTFF Cold Start under weak GNSS
- signal.
-
- Steps:
- 1. Disable SUPL mode.
- 2. Set attenuation value to weak GNSS signal.
- 3. TTFF Cold Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Cold Start results should be within
- weak_signal_xtra_cs_criteria.
- """
- self.xtra_ttff_weak_gnss_signal("cs", self.weak_signal_xtra_cs_criteria)
-
- @test_tracker_info(uuid="2a285be7-3571-49fb-8825-01efa2e65f10")
- def test_xtra_ttff_ws_weak_gnss_signal(self):
- """Verify XTRA/LTO functionality of TTFF Warm Start under weak GNSS
- signal.
-
- Steps:
- 1. Disable SUPL mode.
2. Set attenuation value to weak GNSS signal.
3. TTFF Warm Start for 10 iteration.
Expected Results:
- XTRA/LTO TTFF Warm Start results should be within
- weak_signal_xtra_ws_criteria.
+ TTFF WS result should be within weak_signal_criteria.
"""
- self.xtra_ttff_weak_gnss_signal("ws", self.weak_signal_xtra_ws_criteria)
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.weak_gnss_signal_attenuation)
+ gutils.run_ttff(self.ad, mode="ws", criteria=self.weak_signal_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
- @test_tracker_info(uuid="249bf484-8b04-4cd9-a372-aa718e5f4ec6")
- def test_xtra_ttff_hs_weak_gnss_signal(self):
- """Verify XTRA/LTO functionality of TTFF Hot Start under weak GNSS
- signal.
+ def test_hs_ttff_in_weak_gnss_signal(self):
+ """Verify TTFF hot start under weak GNSS signal.
Steps:
- 1. Disable SUPL mode.
2. Set attenuation value to weak GNSS signal.
3. TTFF Hot Start for 10 iteration.
Expected Results:
- XTRA/LTO TTFF Hot Start results should be within
- weak_signal_xtra_hs_criteria.
+ TTFF HS result should be within weak_signal_criteria.
"""
- self.xtra_ttff_weak_gnss_signal("hs", self.weak_signal_xtra_hs_criteria)
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.weak_gnss_signal_attenuation)
+ gutils.run_ttff(self.ad, mode="hs", criteria=self.weak_signal_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
- @test_tracker_info(uuid="beeb3454-bcb2-451e-83fb-26289e89b515")
- def test_xtra_ttff_cs_wifi(self):
- """Verify XTRA/LTO functionality of TTFF Cold Start with WiFi.
-
- Steps:
- 1. Disable SUPL mode and turn airplane mode on.
- 2. Connect to WiFi.
- 3. TTFF Cold Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Cold Start results should be within
- xtra_cs_criteria.
- """
- self.xtra_ttff_wifi("cs", self.xtra_cs_criteria)
-
- @test_tracker_info(uuid="f6e79b31-99d5-49ca-974f-4543957ea449")
- def test_xtra_ttff_ws_wifi(self):
- """Verify XTRA/LTO functionality of TTFF Warm Start with WiFi.
-
- Steps:
- 1. Disable SUPL mode and turn airplane mode on.
- 2. Connect to WiFi.
- 3. TTFF Warm Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Warm Start results should be within xtra_ws_criteria.
- """
- self.xtra_ttff_wifi("ws", self.xtra_ws_criteria)
-
- @test_tracker_info(uuid="8981363c-f64f-4c37-9674-46733c40473b")
- def test_xtra_ttff_hs_wifi(self):
- """Verify XTRA/LTO functionality of TTFF Hot Start with WiFi.
-
- Steps:
- 1. Disable SUPL mode and turn airplane mode on.
- 2. Connect to WiFi.
- 3. TTFF Hot Start for 10 iteration.
-
- Expected Results:
- XTRA/LTO TTFF Hot Start results should be within xtra_hs_criteria.
- """
- self.xtra_ttff_wifi("hs", self.xtra_hs_criteria)
-
- @test_tracker_info(uuid="1745b8a4-5925-4aa0-809a-1b17e848dc9c")
- def test_xtra_modem_ssr(self):
- """Verify XTRA/LTO functionality after modem silent reboot /
- GPS daemons restart.
-
- Steps:
- 1. Trigger modem crash by adb/Restart GPS daemons by killing PID.
- 2. Wait 1 minute for modem to recover.
- 3. XTRA/LTO TTFF Cold Start for 3 iteration.
- 4. Repeat Step1. to Step 3. for 5 times.
-
- Expected Results:
- All XTRA/LTO TTFF Cold Start results should be within
- xtra_cs_criteria.
- """
- xtra_ssr_test_result_all = []
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for times in range(1, 6):
- begin_time = get_current_epoch_time()
- if gutils.check_chipset_vendor_by_qualcomm(self.ad):
- test_info = "XTRA after Modem SSR"
- gnss_trigger_modem_ssr_by_mds(self.ad)
- else:
- test_info = "LTO after restarting GPS daemons"
- gutils.restart_gps_daemons(self.ad)
- if not verify_internet_connection(self.ad.log, self.ad, retries=3,
- expected_state=True):
- raise signals.TestFailure("Fail to connect to LTE network.")
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=3)
- ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
- self.pixel_lab_location)
- xtra_ssr_test_result = check_ttff_data(
- self.ad, ttff_data, ttff_mode="Cold Start",
- criteria=self.xtra_cs_criteria)
- self.ad.log.info("%s test %d times -> %s" % (
- test_info, times, xtra_ssr_test_result))
- xtra_ssr_test_result_all.append(xtra_ssr_test_result)
- asserts.assert_true(all(xtra_ssr_test_result_all),
- "TTFF fails to reach designated criteria")
-
- @test_tracker_info(uuid="4d6e81e1-3abb-4e03-b732-7b6b497a2258")
- def test_xtra_download_mobile_data(self):
- """Verify XTRA/LTO data could be downloaded via mobile data.
-
- Steps:
- 1. Delete all GNSS aiding data.
- 2. Get location fixed.
- 3. Verify whether XTRA/LTO is downloaded and injected.
- 4. Repeat Step 1. to Step 3. for 5 times.
-
- Expected Results:
- XTRA/LTO data is properly downloaded and injected via mobile data.
- """
- mobile_xtra_result_all = []
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for i in range(1, 6):
- begin_time = get_current_epoch_time()
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- time.sleep(5)
- start_gnss_by_gtw_gpstool(self.ad, False)
- mobile_xtra_result = check_xtra_download(self.ad, begin_time)
- self.ad.log.info("Iteration %d => %s" % (i, mobile_xtra_result))
- mobile_xtra_result_all.append(mobile_xtra_result)
- asserts.assert_true(all(mobile_xtra_result_all),
- "Fail to Download and Inject XTRA/LTO File.")
-
- @test_tracker_info(uuid="625ac665-1446-4406-a722-e6a19645222c")
- def test_xtra_download_wifi(self):
- """Verify XTRA/LTO data could be downloaded via WiFi.
-
- Steps:
- 1. Connect to WiFi.
- 2. Delete all GNSS aiding data.
- 3. Get location fixed.
- 4. Verify whether XTRA/LTO is downloaded and injected.
- 5. Repeat Step 2. to Step 4. for 5 times.
-
- Expected Results:
- XTRA data is properly downloaded and injected via WiFi.
- """
- wifi_xtra_result_all = []
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- self.ad.log.info("Turn airplane mode on")
- self.ad.droid.connectivityToggleAirplaneMode(True)
- wifi_toggle_state(self.ad, True)
- connect_to_wifi_network(
- self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
- for i in range(1, 6):
- begin_time = get_current_epoch_time()
- process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- time.sleep(5)
- start_gnss_by_gtw_gpstool(self.ad, False)
- wifi_xtra_result = check_xtra_download(self.ad, begin_time)
- wifi_xtra_result_all.append(wifi_xtra_result)
- self.ad.log.info("Iteration %d => %s" % (i, wifi_xtra_result))
- asserts.assert_true(all(wifi_xtra_result_all),
- "Fail to Download and Inject XTRA/LTO File.")
-
- @test_tracker_info(uuid="2a9f2890-3c0a-48b8-821d-bf97e36355e9")
def test_quick_toggle_gnss_state(self):
"""Verify GNSS can still work properly after quick toggle GNSS off
to on.
@@ -1219,70 +590,10 @@
Expected Results:
No single Timeout is seen in 10 iterations.
"""
- enable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
start_toggle_gnss_by_gtw_gpstool(
self.ad, iteration=self.ttff_test_cycle)
- @test_tracker_info(uuid="9f565b32-9938-42c0-a29d-f4d28b5f4d75")
- def test_supl_system_server_restart(self):
- """Verify SUPL functionality after system server restart.
-
- Steps:
- 1. Kill XTRA/LTO daemon to support SUPL only case.
- 2. Get location fixed within supl_cs_criteria.
- 3. Restarts android runtime.
- 4. Get location fixed within supl_cs_criteria.
-
- Expected Results:
- Location fixed within supl_cs_criteria.
- """
- overall_test_result = []
- kill_xtra_daemon(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for test_loop in range(1, 6):
- process_gnss_by_gtw_gpstool(self.ad, self.supl_cs_criteria)
- start_gnss_by_gtw_gpstool(self.ad, False)
- self.ad.restart_runtime()
- self.ad.unlock_screen(password=None)
- test_result = process_gnss_by_gtw_gpstool(self.ad,
- self.supl_cs_criteria)
- start_gnss_by_gtw_gpstool(self.ad, False)
- self.ad.log.info("Iteration %d => %s" % (test_loop, test_result))
- overall_test_result.append(test_result)
- asserts.assert_true(all(overall_test_result),
- "SUPL fail after system server restart.")
-
- @test_tracker_info(uuid="a9a64900-9016-46d0-ad7e-cab30e8152cd")
- def test_xtra_system_server_restart(self):
- """Verify XTRA/LTO functionality after system server restart.
-
- Steps:
- 1. Disable SUPL mode.
- 2. Get location fixed within xtra_cs_criteria.
- 3. Restarts android runtime.
- 4. Get location fixed within xtra_cs_criteria.
-
- Expected Results:
- Location fixed within xtra_cs_criteria.
- """
- overall_test_result = []
- disable_supl_mode(self.ad)
- self.start_qxdm_and_tcpdump_log()
- for test_loop in range(1, 6):
- process_gnss_by_gtw_gpstool(self.ad, self.xtra_cs_criteria)
- start_gnss_by_gtw_gpstool(self.ad, False)
- self.ad.restart_runtime()
- self.ad.unlock_screen(password=None)
- test_result = process_gnss_by_gtw_gpstool(self.ad,
- self.xtra_cs_criteria)
- start_gnss_by_gtw_gpstool(self.ad, False)
- self.ad.log.info("Iteration %d => %s" % (test_loop, test_result))
- overall_test_result.append(test_result)
- asserts.assert_true(all(overall_test_result),
- "XTRA/LTO fail after system server restart.")
-
- @test_tracker_info(uuid="ab5ef9f7-0b28-48ed-a693-7f1d902ca3e1")
def test_gnss_init_after_reboot(self):
"""Verify SUPL and XTRA/LTO functionality after reboot.
@@ -1296,12 +607,14 @@
Location fixed within supl_hs_criteria.
"""
overall_test_result = []
- enable_supl_mode(self.ad)
+ # As b/252971345 requests, we need the log before reboot for debugging.
+ gutils.start_pixel_logger(self.ad)
process_gnss_by_gtw_gpstool(self.ad, self.supl_cs_criteria)
start_gnss_by_gtw_gpstool(self.ad, False)
+ gutils.stop_pixel_logger(self.ad)
for test_loop in range(1, 11):
reboot(self.ad)
- self.start_qxdm_and_tcpdump_log()
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
if is_device_wearable(self.ad):
test_result = process_gnss_by_gtw_gpstool(
self.ad, self.wearable_reboot_hs_criteria, clear_data=False)
@@ -1318,63 +631,184 @@
asserts.assert_true(all(overall_test_result),
"GNSS init fail after reboot.")
- @test_tracker_info(uuid="2c62183a-4354-4efc-92f2-84580cbd3398")
- def test_lto_download_after_reboot(self):
- """Verify LTO data could be downloaded and injected after device reboot.
+ def test_host_gnssstatus_validation(self):
+ """Verify GnssStatus integrity during host tracking for 1 minute.
Steps:
- 1. Reboot device.
- 2. Verify whether LTO is auto downloaded and injected without trigger GPS.
- 3. Repeat Step 1 to Step 2 for 5 times.
+ 1. Launch GTW_GPSTool.
+ 2. GNSS tracking for 1 minute with 1 second frequency.
+ 3. Validate all the GnssStatus raw data.(SV, SVID, Elev, Azim)
Expected Results:
- LTO data is properly downloaded and injected at the first time tether to phone.
+ GnssStatus obj should return no failures
"""
- reboot_lto_test_results_all = []
- disable_supl_mode(self.ad)
- for times in range(1, 6):
- delete_lto_file(self.ad)
- reboot(self.ad)
- self.start_qxdm_and_tcpdump_log()
- # Wait 20 seconds for boot busy and lto auto-download time
- time.sleep(20)
- begin_time = get_current_epoch_time()
- reboot_lto_test_result = gutils.check_xtra_download(self.ad, begin_time)
- self.ad.log.info("Iteration %d => %s" % (times, reboot_lto_test_result))
- reboot_lto_test_results_all.append(reboot_lto_test_result)
- gutils.stop_pixel_logger(self.ad)
- tutils.stop_adb_tcpdump(self.ad)
- asserts.assert_true(all(reboot_lto_test_results_all),
- "Fail to Download and Inject LTO File.")
+ gnss_tracking_via_gtw_gpstool(self.ad, self.standalone_cs_criteria,
+ api_type="gnss", testtime=1)
+ parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss",
+ validate_gnssstatus=True)
- @test_tracker_info(uuid="a7048a4f-8a40-40a4-bb6c-7fc90e8227bd")
- def test_ws_with_assist(self):
- """Verify Warm Start functionality with existed LTO data.
+ def test_onchip_gnssstatus_validation(self):
+ """Verify GnssStatus integrity during onchip tracking for 1 minute.
Steps:
- 1. Disable SUPL mode.
- 2. Make LTO is downloaded.
- 3. Turn on AirPlane mode to make sure there's no network connection.
- 4. TTFF Warm Start with Assist for 10 iteration.
+ 1. Launch GTW_GPSTool.
+ 2. GNSS tracking for 1 minute with 6 second frequency.
+ 3. Validate all the GnssStatus raw data.(SV, SVID, Elev, Azim)
Expected Results:
- All TTFF Warm Start with Assist results should be within
- xtra_ws_criteria.
+ GnssStatus obj should return no failures
"""
- self.ttff_with_assist("ws", self.xtra_ws_criteria)
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ raise signals.TestSkip("Not BRCM chipset. Skip the test.")
+ gnss_tracking_via_gtw_gpstool(self.ad, self.standalone_cs_criteria,
+ api_type="gnss", testtime=1, freq=self.onchip_interval)
+ parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss",
+ validate_gnssstatus=True)
- @test_tracker_info(uuid="c5fb9519-63b0-42bd-bd79-fce7593604ea")
- def test_cs_with_assist(self):
- """Verify Cold Start functionality with existed LTO data.
-
- Steps:
- 1. Disable SUPL mode.
- 2. Make sure LTO is downloaded.
- 3. Turn on AirPlane mode to make sure there's no network connection.
- 4. TTFF Cold Start with Assist for 10 iteration.
-
- Expected Results:
- All TTFF Cold Start with Assist results should be within
- standalone_cs_criteria.
+ def test_location_update_after_resuming_from_deep_suspend(self):
+ """Verify the GPS location reported after resume from suspend mode
+ 1. Enable GPS location report for 1 min to make sure the GPS is working
+ 2. Force DUT into deep suspend mode for a while(3 times with 15s interval)
+ 3. Enable GPS location report for 5 mins
+ 4. Check the report frequency
+ 5. Check the location fix rate
"""
- self.ttff_with_assist("csa", self.standalone_cs_criteria)
+
+ gps_enable_minutes = 1
+ gnss_tracking_via_gtw_gpstool(self.ad, criteria=self.supl_cs_criteria, api_type="gnss",
+ testtime=gps_enable_minutes)
+ result = parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss")
+ self.ad.log.debug("Location report details before suspend")
+ self.ad.log.debug(result)
+ gutils.validate_location_fix_rate(self.ad, result, run_time=gps_enable_minutes,
+ fix_rate_criteria=0.95)
+
+ gutils.deep_suspend_device(self.ad)
+
+ gps_enable_minutes = 5
+ gnss_tracking_via_gtw_gpstool(self.ad, criteria=self.supl_cs_criteria, api_type="gnss",
+ testtime=gps_enable_minutes)
+ result = parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss")
+ self.ad.log.debug("Location report details after suspend")
+ self.ad.log.debug(result)
+
+ location_report_time = list(result.keys())
+ gutils.check_location_report_interval(self.ad, location_report_time,
+ gps_enable_minutes * 60, tolerance=0.01)
+ gutils.validate_location_fix_rate(self.ad, result, run_time=gps_enable_minutes,
+ fix_rate_criteria=0.99)
+
+ def test_location_mode_in_battery_saver_with_screen_off(self):
+ """Ensure location request with foreground permission can work
+ in battery saver mode (screen off)
+
+ 1. unplug power
+ 2. enter battery saver mode
+ 3. start tracking for 2 mins with screen off
+ 4. repest step 3 for 3 times
+ """
+ try:
+ gutils.set_battery_saver_mode(self.ad, state=True)
+ test_time = 2
+ for i in range(1, 4):
+ self.ad.log.info("Tracking attempt %s" % str(i))
+ gnss_tracking_via_gtw_gpstool(
+ self.ad, criteria=self.supl_cs_criteria, api_type="gnss", testtime=test_time,
+ is_screen_off=True)
+ result = parse_gtw_gpstool_log(self.ad, self.pixel_lab_location, api_type="gnss")
+ gutils.validate_location_fix_rate(self.ad, result, run_time=test_time,
+ fix_rate_criteria=0.99)
+ finally:
+ gutils.set_battery_saver_mode(self.ad, state=False)
+
+ def test_measure_adr_rate_after_10_mins_tracking(self):
+ """Verify ADR rate
+
+ 1. Enable "Force full gnss measurement"
+ 2. Start tracking with GnssMeasurement enabled for 10 mins
+ 3. Check ADR usable rate / valid rate
+ 4. Disable "Force full gnss measurement"
+ """
+ adr_threshold = self.adr_ratio_threshold.get(self.ad.model)
+ if not adr_threshold:
+ self.ad.log.warn((f"Can't get '{self.ad.model}' threshold from config "
+ f"{self.adr_ratio_threshold}, use default threshold 0.5"))
+ adr_threshold = 0.5
+ with gutils.full_gnss_measurement(self.ad):
+ gnss_tracking_via_gtw_gpstool(self.ad, criteria=self.supl_cs_criteria, api_type="gnss",
+ testtime=10, meas_flag=True)
+ gutils.validate_adr_rate(self.ad, pass_criteria=float(adr_threshold))
+
+
+ def test_hal_crashing_should_resume_tracking(self):
+ """Make sure location request can be resumed after HAL restart.
+
+ 1. Start GPS tool and get First Fixed
+ 2. Wait for 1 min for tracking
+ 3. Restart HAL service
+ 4. Wait for 1 min for tracking
+ 5. Check fix rate
+ """
+
+ first_fixed_time = process_gnss_by_gtw_gpstool(self.ad, criteria=self.supl_cs_criteria)
+ begin_time = int(first_fixed_time.timestamp() * 1000)
+
+ self.ad.log.info("Start 2 mins tracking")
+
+ gutils.wait_n_mins_for_gnss_tracking(self.ad, begin_time, testtime=1,
+ ignore_hal_crash=False)
+ gutils.restart_hal_service(self.ad)
+ # The test case is designed to run the tracking for 2 mins, so we assign testime to 2 to
+ # indicate the total run time is 2 mins (starting from begin_time).
+ gutils.wait_n_mins_for_gnss_tracking(self.ad, begin_time, testtime=2, ignore_hal_crash=True)
+
+ start_gnss_by_gtw_gpstool(self.ad, state=False)
+
+ result = parse_gtw_gpstool_log(self.ad, self.pixel_lab_location)
+ gutils.validate_location_fix_rate(self.ad, result, run_time=2,
+ fix_rate_criteria=0.95)
+
+
+ def test_power_save_mode_should_apply_latest_measurement_setting(self):
+ """Ensure power save mode will apply the GNSS measurement setting.
+
+ 1. Turn off full GNSS measurement.
+ 2. Run tracking for 2 mins
+ 3. Check the power save mode status
+ 4. Turn on full GNSS measurement and re-register measurement callback
+ 6. Run tracking for 30s
+ 7. Check the power save mode status
+ 8. Turn off full GNSS measurement and re-register measurement callback
+ 9. Run tracking for 2 mins
+ 10. Check the power save mode status
+ """
+ def wait_for_power_state_changes(wait_time):
+ gutils.re_register_measurement_callback(self.ad)
+ tracking_begin_time = get_current_epoch_time()
+ gutils.wait_n_mins_for_gnss_tracking(self.ad, tracking_begin_time, testtime=wait_time)
+ return tracking_begin_time
+
+ if self.ad.model.lower() == "sunfish":
+ raise signals.TestSkip(
+ "According to b/241049795, it's HW issue and won't be fixed.")
+
+ gutils.start_pixel_logger(self.ad)
+ with gutils.run_gnss_tracking(self.ad, criteria=self.supl_cs_criteria, meas_flag=True):
+ start_time = wait_for_power_state_changes(wait_time=2)
+ gutils.check_power_save_mode_status(
+ self.ad, full_power=False, begin_time=start_time,
+ brcm_error_allowlist=self.brcm_error_log_allowlist)
+
+ with gutils.full_gnss_measurement(self.ad):
+ start_time = wait_for_power_state_changes(wait_time=0.5)
+ gutils.check_power_save_mode_status(
+ self.ad, full_power=True, begin_time=start_time,
+ brcm_error_allowlist=self.brcm_error_log_allowlist)
+
+ start_time = wait_for_power_state_changes(wait_time=2)
+ gutils.check_power_save_mode_status(
+ self.ad, full_power=False, begin_time=start_time,
+ brcm_error_allowlist=self.brcm_error_log_allowlist)
+
+ gutils.stop_pixel_logger(self.ad)
+
diff --git a/acts_tests/tests/google/gnss/GnssHsSenTest.py b/acts_tests/tests/google/gnss/GnssHsSenTest.py
index 5269ae0..bd4e398 100644
--- a/acts_tests/tests/google/gnss/GnssHsSenTest.py
+++ b/acts_tests/tests/google/gnss/GnssHsSenTest.py
@@ -13,11 +13,12 @@
# 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.
+"""Lab GNSS Hot Start Sensitivity Test"""
import os
from acts_contrib.test_utils.gnss.GnssBlankingBase import GnssBlankingBase
from acts_contrib.test_utils.gnss.dut_log_test_utils import get_gpstool_logs
-from acts_contrib.test_utils.gnss.gnss_test_utils import excute_eecoexer_function
+from acts_contrib.test_utils.gnss.gnss_test_utils import execute_eecoexer_function
class GnssHsSenTest(GnssBlankingBase):
@@ -25,11 +26,19 @@
def __init__(self, controllers):
super().__init__(controllers)
- self.gnss_simulator_power_level = -130
- self.sa_sensitivity = -150
- self.gnss_pwr_lvl_offset = 5
+ self.cell_tx_ant = None
+ self.cell_pwr = None
+ self.eecoex_func = ''
+ self.coex_stop_cmd = ''
+ self.coex_params = {}
- def gnss_hot_start_sensitivity_search_base(self, cellular_enable=False):
+ def setup_class(self):
+ super().setup_class()
+ self.coex_params = self.user_params.get('coex_params', {})
+ self.cell_tx_ant = self.coex_params.get('cell_tx_ant', 'PRIMARY')
+ self.cell_pwr = self.coex_params.get('cell_pwr', 'Infinity')
+
+ def gnss_hot_start_sensitivity_search_base(self, coex_enable=False):
"""
Perform GNSS hot start sensitivity search.
@@ -41,49 +50,32 @@
# Get parameters from user_params.
first_wait = self.user_params.get('first_wait', 300)
wait_between_pwr = self.user_params.get('wait_between_pwr', 60)
- gnss_pwr_sweep = self.user_params.get('gnss_pwr_sweep')
- gnss_init_pwr = gnss_pwr_sweep.get('init')
- self.gnss_simulator_power_level = gnss_init_pwr[0]
- self.sa_sensitivity = gnss_init_pwr[1]
- self.gnss_pwr_lvl_offset = gnss_init_pwr[2]
- gnss_pwr_fine_sweep = gnss_pwr_sweep.get('fine_sweep')
ttft_iteration = self.user_params.get('ttff_iteration', 25)
# Start the test item with gnss_init_power_setting.
- if self.gnss_init_power_setting(first_wait):
- self.log.info('Successfully set the GNSS power level to %d' %
- self.sa_sensitivity)
+ ret, pwr_lvl = self.gnss_init_power_setting(first_wait)
+ if ret:
+ self.log.info(f'Successfully set the GNSS power level to {pwr_lvl}')
# Create gnss log folders for init and cellular sweep
gnss_init_log_dir = os.path.join(self.gnss_log_path, 'GNSS_init')
# Pull all exist GPStool logs into GNSS_init folder
get_gpstool_logs(self.dut, gnss_init_log_dir, False)
-
- if cellular_enable:
- self.log.info('Start cellular coexistence test.')
- # Set cellular Tx power level.
- eecoex_cmd = self.eecoex_func.format('Infinity')
- eecoex_cmd_file_str = eecoex_cmd.replace(',', '_')
- excute_eecoexer_function(self.dut, eecoex_cmd)
- else:
- self.log.info('Start stand alone test.')
- eecoex_cmd_file_str = 'Stand_alone'
-
- for i, gnss_pwr in enumerate(gnss_pwr_fine_sweep):
- self.log.info('Start fine GNSS power level sweep part %d' %
- (i + 1))
- sweep_start = gnss_pwr[0]
- sweep_stop = gnss_pwr[1]
- sweep_offset = gnss_pwr[2]
- self.log.info(
- 'The GNSS simulator (start, stop, offset): (%.1f, %.1f, %.1f)'
- % (sweep_start, sweep_stop, sweep_offset))
- result, sensitivity = self.hot_start_gnss_power_sweep(
- sweep_start, sweep_stop, sweep_offset, wait_between_pwr,
- ttft_iteration, True, eecoex_cmd_file_str)
- if not result:
- break
- self.log.info('The sensitivity level is: %.1f' % sensitivity)
+ if coex_enable:
+ self.log.info('Start coexistence test.')
+ eecoex_cmd_file_str = self.eecoex_func.replace(',', '_')
+ execute_eecoexer_function(self.dut, self.eecoex_func)
+ else:
+ self.log.info('Start stand alone test.')
+ eecoex_cmd_file_str = 'Stand_alone'
+ for i, gnss_pwr_swp in enumerate(self.gnss_pwr_sweep_fine_sweep_ls):
+ self.log.info(f'Start fine GNSS power level sweep part {i + 1}')
+ result, sensitivity = self.hot_start_gnss_power_sweep(
+ gnss_pwr_swp, wait_between_pwr, ttft_iteration, True,
+ eecoex_cmd_file_str)
+ if not result:
+ break
+ self.log.info(f'The sensitivity level is: {sensitivity}')
def test_hot_start_sensitivity_search(self):
"""
@@ -95,86 +87,127 @@
"""
GNSS hot start GSM850 Ch190 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,2,850,190,1,1,{}'
- self.log.info('Running GSM850 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,2,850,190,1,{self.cell_tx_ant},{self.cell_pwr}'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running GSM850 with {self.cell_tx_ant} antenna \
+ and GNSS coexistence sensitivity search.'
+
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_gsm900(self):
"""
GNSS hot start GSM900 Ch20 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,2,900,20,1,1,{}'
- self.log.info('Running GSM900 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,2,900,20,1,{self.cell_tx_ant},{self.cell_pwr}'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running GSM900 with {self.cell_tx_ant} \
+ antenna and GNSS coexistence sensitivity search.'
+
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_gsm1800(self):
"""
GNSS hot start GSM1800 Ch699 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,2,1800,699,1,1,{}'
- self.log.info(
- 'Running GSM1800 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,2,1800,699,1,{self.cell_tx_ant},{self.cell_pwr}'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running GSM1800 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_gsm1900(self):
"""
GNSS hot start GSM1900 Ch661 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,2,1900,661,1,1,{}'
- self.log.info(
- 'Running GSM1900 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,2,1900,661,1,{self.cell_tx_ant},{self.cell_pwr}'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running GSM1900 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b38(self):
"""
GNSS hot start LTE B38 Ch38000 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,38,38000,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B38 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,38,38000,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B38 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b39(self):
"""
GNSS hot start LTE B39 Ch38450 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,39,38450,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B38 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,39,38450,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B38 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b40(self):
"""
GNSS hot start LTE B40 Ch39150 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,40,39150,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B38 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,40,39150,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B38 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b41(self):
"""
GNSS hot start LTE B41 Ch40620 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,41,40620,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B41 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,41,40620,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B41 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b42(self):
"""
GNSS hot start LTE B42 Ch42590 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,42,42590,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B42 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,42,42590,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B42 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
def test_hot_start_sensitivity_search_lte_b48(self):
"""
GNSS hot start LTE B48 Ch55990 coexistence sensitivity search.
"""
- self.eecoex_func = 'CELLR,5,48,55990,true,PRIMARY,{},10MHz,0,12'
- self.log.info(
- 'Running LTE B48 and GNSS coexistence sensitivity search.')
+ self.eecoex_func = f'CELLR,5,48,55990,true,{self.cell_tx_ant},{self.cell_pwr},10MHz,0,12'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = f'Running LTE B48 {self.cell_tx_ant} antenna and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
self.gnss_hot_start_sensitivity_search_base(True)
+
+ def test_hot_start_sensitivity_search_fr2_n2605(self):
+ """
+ GNSS hot start 5G NR B260 CH2234165 coexistence sensitivity search.
+ """
+ self.eecoex_func = f'CELLR,30,260,2234165,183,{self.cell_pwr}'
+ self.coex_stop_cmd = 'CELLR,19'
+ msg = 'Running 5G NR B260 CH2234165 and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
+ self.gnss_hot_start_sensitivity_search_base(True)
+
+ def test_hot_start_sensitivity_custom_case(self):
+ """
+ GNSS hot start custom case coexistence sensitivity search.
+ """
+ cust_cmd = self.coex_params.get('custom_cmd', '')
+ cust_stop_cmd = self.coex_params.get('custom_stop_cmd', '')
+ if cust_cmd and cust_stop_cmd:
+ self.eecoex_func = cust_cmd
+ self.coex_stop_cmd = cust_stop_cmd
+ msg = f'Running custom {self.eecoex_func} and GNSS coexistence sensitivity search.'
+ self.log.info(msg)
+ self.gnss_hot_start_sensitivity_search_base(True)
+ else:
+ self.log.warning('No custom coex command is provided')
diff --git a/acts_tests/tests/google/gnss/GnssSuplTest.py b/acts_tests/tests/google/gnss/GnssSuplTest.py
new file mode 100644
index 0000000..853a228
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssSuplTest.py
@@ -0,0 +1,294 @@
+from multiprocessing import Process
+import time
+
+from acts import asserts
+from acts import signals
+from acts.base_test import BaseTestClass
+from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
+from acts_contrib.test_utils.gnss import supl
+from acts_contrib.test_utils.gnss import gnss_defines
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
+from acts_contrib.test_utils.tel.tel_data_utils import http_file_download_by_sl4a
+from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log
+from acts_contrib.test_utils.tel.tel_logging_utils import stop_adb_tcpdump
+from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log
+from acts_contrib.test_utils.tel.tel_test_utils import check_call_state_connected_by_adb
+from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection
+from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode
+from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts.utils import get_current_epoch_time
+
+
+class GnssSuplTest(BaseTestClass):
+ def setup_class(self):
+ super().setup_class()
+ self.ad = self.android_devices[0]
+ req_params = [
+ "pixel_lab_network", "standalone_cs_criteria", "supl_cs_criteria", "supl_ws_criteria",
+ "supl_hs_criteria", "default_gnss_signal_attenuation", "pixel_lab_location",
+ "qdsp6m_path", "collect_logs", "ttff_test_cycle",
+ "supl_capabilities", "no_gnss_signal_attenuation", "set_attenuator"
+ ]
+ self.unpack_userparams(req_param_names=req_params)
+ # create hashmap for SSID
+ self.ssid_map = {}
+ for network in self.pixel_lab_network:
+ SSID = network["SSID"]
+ self.ssid_map[SSID] = network
+ self.init_device()
+
+ def only_brcm_device_runs_wifi_case(self):
+ """SUPL over wifi is only supported by BRCM devices, for QUAL device, skip the test.
+ """
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ raise signals.TestSkip("Qualcomm device doesn't support SUPL over wifi")
+
+ def wearable_btwifi_should_skip_mobile_data_case(self):
+ if gutils.is_wearable_btwifi(self.ad):
+ raise signals.TestSkip("Skip mobile data case for BtWiFi sku")
+
+ def init_device(self):
+ """Init GNSS test devices for SUPL suite."""
+ gutils._init_device(self.ad)
+ gutils.disable_vendor_orbit_assistance_data(self.ad)
+ gutils.enable_supl_mode(self.ad)
+ self.enable_supl_over_wifi()
+ gutils.reboot(self.ad)
+
+ def enable_supl_over_wifi(self):
+ if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ supl.set_supl_over_wifi_state(self.ad, turn_on=True)
+
+ def setup_test(self):
+ gutils.log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
+ gutils.clear_logd_gnss_qxdm_log(self.ad)
+ gutils.get_baseband_and_gms_version(self.ad)
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=False)
+ if gutils.is_wearable_btwifi(self.ad):
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.connect_to_wifi_network(self.ad,
+ self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+ else:
+ wutils.wifi_toggle_state(self.ad, False)
+ gutils.set_mobile_data(self.ad, state=True)
+ if not verify_internet_connection(self.ad.log, self.ad, retries=3,
+ expected_state=True):
+ raise signals.TestFailure("Fail to connect to LTE network.")
+ # Once the device is rebooted, the xtra service will be alive again
+ # In order not to affect the supl case, disable it in setup_test.
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ gutils.disable_qualcomm_orbit_assistance_data(self.ad)
+
+ def teardown_test(self):
+ if self.collect_logs:
+ gutils.stop_pixel_logger(self.ad)
+ stop_adb_tcpdump(self.ad)
+ if self.set_attenuator:
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.default_gnss_signal_attenuation)
+ gutils.log_current_epoch_time(self.ad, "test_end_time")
+
+ def on_fail(self, test_name, begin_time):
+ if self.collect_logs:
+ self.ad.take_bug_report(test_name, begin_time)
+ gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path)
+ self.get_brcm_gps_xml_to_sponge()
+ get_tcpdump_log(self.ad, test_name, begin_time)
+
+ def get_brcm_gps_xml_to_sponge(self):
+ # request from b/250506003 - to check the SUPL setting
+ if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ self.ad.pull_files(gnss_defines.BCM_GPS_XML_PATH, self.ad.device_log_path)
+
+ def run_ttff(self, mode, criteria):
+ """Triggers TTFF.
+
+ Args:
+ mode: "cs", "ws" or "hs"
+ criteria: Criteria for the test.
+ """
+ return gutils.run_ttff(self.ad, mode, criteria, self.ttff_test_cycle,
+ self.pixel_lab_location, self.collect_logs)
+
+ def supl_ttff_weak_gnss_signal(self, mode, criteria):
+ """Verify SUPL TTFF functionality under weak GNSS signal.
+
+ Args:
+ mode: "cs", "ws" or "hs"
+ criteria: Criteria for the test.
+ """
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.weak_gnss_signal_attenuation)
+ self.run_ttff(mode, criteria)
+
+ def connect_to_wifi_with_mobile_data_off(self):
+ gutils.set_mobile_data(self.ad, False)
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+
+ def connect_to_wifi_with_airplane_mode_on(self):
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=True)
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+
+ def check_position_mode(self, begin_time: int, mode: str):
+ logcat_results = self.ad.search_logcat(
+ matching_string="setting position_mode to", begin_time=begin_time)
+ return all([result["log_message"].split(" ")[-1] == mode for result in logcat_results])
+
+ def test_supl_capabilities(self):
+ """Verify SUPL capabilities.
+
+ Steps:
+ 1. Root DUT.
+ 2. Check SUPL capabilities.
+
+ Expected Results:
+ CAPABILITIES=0x37 which supports MSA + MSB.
+ CAPABILITIES=0x17 = ON_DEMAND_TIME | MSA | MSB | SCHEDULING
+ """
+ if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ raise signals.TestSkip("Not Qualcomm chipset. Skip the test.")
+ capabilities_state = str(
+ self.ad.adb.shell(
+ "cat vendor/etc/gps.conf | grep CAPABILITIES")).split("=")[-1]
+ self.ad.log.info("SUPL capabilities - %s" % capabilities_state)
+
+ asserts.assert_true(capabilities_state in self.supl_capabilities,
+ "Wrong default SUPL capabilities is set. Found %s, "
+ "expected any of %r" % (capabilities_state,
+ self.supl_capabilities))
+
+
+ def test_supl_ttff_cs(self):
+ """Verify SUPL functionality of TTFF Cold Start.
+
+ Steps:
+ 1. Kill XTRA/LTO daemon to support SUPL only case.
+ 2. SUPL TTFF Cold Start for 10 iteration.
+
+ Expected Results:
+ All SUPL TTFF Cold Start results should be less than
+ supl_cs_criteria.
+ """
+ self.run_ttff("cs", self.supl_cs_criteria)
+
+ def test_supl_ttff_ws(self):
+ """Verify SUPL functionality of TTFF Warm Start.
+
+ Steps:
+ 1. Kill XTRA/LTO daemon to support SUPL only case.
+ 2. SUPL TTFF Warm Start for 10 iteration.
+
+ Expected Results:
+ All SUPL TTFF Warm Start results should be less than
+ supl_ws_criteria.
+ """
+ self.run_ttff("ws", self.supl_ws_criteria)
+
+ def test_supl_ttff_hs(self):
+ """Verify SUPL functionality of TTFF Hot Start.
+
+ Steps:
+ 1. Kill XTRA/LTO daemon to support SUPL only case.
+ 2. SUPL TTFF Hot Start for 10 iteration.
+
+ Expected Results:
+ All SUPL TTFF Hot Start results should be less than
+ supl_hs_criteria.
+ """
+ self.run_ttff("hs", self.supl_hs_criteria)
+
+ def test_cs_ttff_supl_over_wifi_with_airplane_mode_on(self):
+ """ Test supl can works through wifi with airplane mode on
+
+ Test steps are executed in the following sequence.
+ - Turn on airplane mode
+ - Connect to wifi
+ - Run SUPL CS TTFF
+ """
+ self.only_brcm_device_runs_wifi_case()
+
+ self.connect_to_wifi_with_airplane_mode_on()
+
+ self.run_ttff(mode="cs", criteria=self.supl_cs_criteria)
+
+ def test_ws_ttff_supl_over_wifi_with_airplane_mode_on(self):
+ """ Test supl can works through wifi with airplane mode on
+
+ Test steps are executed in the following sequence.
+ - Turn on airplane mode
+ - Connect to wifi
+ - Run SUPL WS TTFF
+ """
+ self.only_brcm_device_runs_wifi_case()
+
+ self.connect_to_wifi_with_airplane_mode_on()
+
+ self.run_ttff("ws", self.supl_ws_criteria)
+
+ def test_hs_ttff_supl_over_wifi_with_airplane_mode_on(self):
+ """ Test supl can works through wifi with airplane mode on
+
+ Test steps are executed in the following sequence.
+ - Turn on airplane mode
+ - Connect to wifi
+ - Run SUPL WS TTFF
+ """
+ self.only_brcm_device_runs_wifi_case()
+
+ self.connect_to_wifi_with_airplane_mode_on()
+
+ self.run_ttff("hs", self.supl_ws_criteria)
+
+ def test_ttff_gla_on(self):
+ """ Test the turn on "Google Location Accuracy" in settings work or not.
+
+ Test steps are executed in the following sequence.
+ - Turn off airplane mode
+ - Connect to Cellular
+ - Turn off LTO/RTO
+ - Turn on SUPL
+ - Turn on GLA
+ - Run CS TTFF
+
+ Expected Results:
+ - The position mode must be "MS_BASED"
+ - The TTFF time should be less than 10 seconds
+ """
+ begin_time = get_current_epoch_time()
+ gutils.gla_mode(self.ad, True)
+
+ self.run_ttff("cs", self.supl_cs_criteria)
+ asserts.assert_true(self.check_position_mode(begin_time, "MS_BASED"),
+ msg=f"Fail to enter the MS_BASED mode")
+
+ def test_ttff_gla_off(self):
+ """ Test the turn off "Google Location Accuracy" in settings work or not.
+
+ Test steps are executed in the following sequence.
+ - Turn off airplane mode
+ - Connect to Cellular
+ - Turn off LTO/RTO
+ - Turn on SUPL
+ - Turn off GLA
+ - Run CS TTFF
+
+ Expected Results:
+ - The position mode must be "standalone"
+ - The TTFF time must be between slower than supl_ws and faster than standalone_cs.
+ """
+ begin_time = get_current_epoch_time()
+ gutils.gla_mode(self.ad, False)
+
+ ttff_data = self.run_ttff("cs", self.standalone_cs_criteria)
+
+ asserts.assert_true(any(float(ttff_data[key].ttff_sec) > self.supl_ws_criteria
+ for key in ttff_data.keys()),
+ msg=f"One or more TTFF Cold Start are faster than \
+ test criteria {self.supl_ws_criteria} seconds")
+
+ asserts.assert_true(self.check_position_mode(begin_time, "standalone"),
+ msg=f"Fail to enter the standalone mode")
diff --git a/acts_tests/tests/google/gnss/GnssVendorFeaturesTest.py b/acts_tests/tests/google/gnss/GnssVendorFeaturesTest.py
new file mode 100644
index 0000000..e94626f
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssVendorFeaturesTest.py
@@ -0,0 +1,290 @@
+import time
+
+from acts import asserts
+from acts import signals
+from acts.base_test import BaseTestClass
+from acts.utils import get_current_epoch_time
+from acts_contrib.test_utils.gnss import gnss_constant
+from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts_contrib.test_utils.tel import tel_logging_utils
+from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection
+from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode
+
+
+class GnssVendorFeaturesTest(BaseTestClass):
+ """Validate vendor specific features."""
+ def setup_class(self):
+ super().setup_class()
+ self.ad = self.android_devices[0]
+ req_params = ["pixel_lab_network", "default_gnss_signal_attenuation", "pixel_lab_location",
+ "qdsp6m_path", "collect_logs", "ttff_test_cycle", "standalone_cs_criteria",
+ "xtra_cs_criteria", "xtra_ws_criteria", "xtra_hs_criteria",
+ "set_attenuator"]
+ self.unpack_userparams(req_param_names=req_params)
+ # create hashmap for SSID
+ self.ssid_map = {}
+ for network in self.pixel_lab_network:
+ SSID = network["SSID"]
+ self.ssid_map[SSID] = network
+ self.init_device()
+
+ def init_device(self):
+ """Init GNSS test devices for vendor features suite."""
+ gutils._init_device(self.ad)
+ gutils.disable_supl_mode(self.ad)
+ gutils.enable_vendor_orbit_assistance_data(self.ad)
+
+ def setup_test(self):
+ gutils.log_current_epoch_time(self.ad, "test_start_time")
+ log_testtracker_uuid(self.ad, self.current_test_name)
+ gutils.clear_logd_gnss_qxdm_log(self.ad)
+ gutils.get_baseband_and_gms_version(self.ad)
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=False)
+ if gutils.is_wearable_btwifi(self.ad):
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.connect_to_wifi_network(self.ad,
+ self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+ else:
+ wutils.wifi_toggle_state(self.ad, False)
+ gutils.set_mobile_data(self.ad, state=True)
+ if not verify_internet_connection(self.ad.log, self.ad, retries=3,
+ expected_state=True):
+ raise signals.TestFailure("Fail to connect to internet.")
+
+ def teardown_test(self):
+ if self.collect_logs:
+ gutils.stop_pixel_logger(self.ad)
+ tel_logging_utils.stop_adb_tcpdump(self.ad)
+ if self.set_attenuator:
+ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators,
+ self.default_gnss_signal_attenuation)
+ gutils.log_current_epoch_time(self.ad, "test_end_time")
+
+ def on_fail(self, test_name, begin_time):
+ if self.collect_logs:
+ self.ad.take_bug_report(test_name, begin_time)
+ gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path)
+ tel_logging_utils.get_tcpdump_log(self.ad, test_name, begin_time)
+
+ def connect_to_wifi_with_airplane_mode_on(self):
+ self.ad.log.info("Turn airplane mode on")
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=True)
+ wutils.wifi_toggle_state(self.ad, True)
+ gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+
+ def ttff_with_assist(self, mode, criteria):
+ """Verify CS/WS TTFF functionality with Assist data.
+
+ Args:
+ mode: "csa" or "ws"
+ criteria: Criteria for the test.
+ """
+ begin_time = get_current_epoch_time()
+ gutils.process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
+ gutils.check_xtra_download(self.ad, begin_time)
+ self.ad.log.info("Turn airplane mode on")
+ toggle_airplane_mode(self.ad.log, self.ad, new_state=True)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, True)
+ gutils.start_ttff_by_gtw_gpstool(self.ad, mode, iteration=self.ttff_test_cycle)
+ ttff_data = gutils.process_ttff_by_gtw_gpstool(self.ad, begin_time, self.pixel_lab_location)
+ result = gutils.check_ttff_data(self.ad, ttff_data, mode, criteria)
+ asserts.assert_true(
+ result, "TTFF %s fails to reach designated criteria of %d "
+ "seconds." % (gnss_constant.TTFF_MODE.get(mode), criteria))
+
+ def test_xtra_ttff_cs_mobile_data(self):
+ """Verify XTRA/LTO functionality of TTFF Cold Start with mobile data.
+
+ Steps:
+ 1. TTFF Cold Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Cold Start results should be within xtra_cs_criteria.
+ """
+ gutils.run_ttff(self.ad, mode="cs", criteria=self.xtra_cs_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_ttff_ws_mobile_data(self):
+ """Verify XTRA/LTO functionality of TTFF Warm Start with mobile data.
+
+ Steps:
+ 1. TTFF Warm Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Warm Start results should be within xtra_ws_criteria.
+ """
+ gutils.run_ttff(self.ad, mode="ws", criteria=self.xtra_ws_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_ttff_hs_mobile_data(self):
+ """Verify XTRA/LTO functionality of TTFF Hot Start with mobile data.
+
+ Steps:
+ 1. TTFF Hot Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Hot Start results should be within xtra_hs_criteria.
+ """
+ gutils.run_ttff(self.ad, mode="hs", criteria=self.xtra_hs_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_ttff_cs_wifi(self):
+ """Verify XTRA/LTO functionality of TTFF Cold Start with WiFi.
+
+ Steps:
+ 1. Turn airplane mode on.
+ 2. Connect to WiFi.
+ 3. TTFF Cold Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Cold Start results should be within
+ xtra_cs_criteria.
+ """
+ self.connect_to_wifi_with_airplane_mode_on()
+ gutils.run_ttff(self.ad, mode="cs", criteria=self.xtra_cs_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_ttff_ws_wifi(self):
+ """Verify XTRA/LTO functionality of TTFF Warm Start with WiFi.
+
+ Steps:
+ 1. Turn airplane mode on.
+ 2. Connect to WiFi.
+ 3. TTFF Warm Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Warm Start results should be within xtra_ws_criteria.
+ """
+ self.connect_to_wifi_with_airplane_mode_on()
+ gutils.run_ttff(self.ad, mode="ws", criteria=self.xtra_ws_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_ttff_hs_wifi(self):
+ """Verify XTRA/LTO functionality of TTFF Hot Start with WiFi.
+
+ Steps:
+ 1. Turn airplane mode on.
+ 2. Connect to WiFi.
+ 3. TTFF Hot Start for 10 iteration.
+
+ Expected Results:
+ XTRA/LTO TTFF Hot Start results should be within xtra_hs_criteria.
+ """
+ self.connect_to_wifi_with_airplane_mode_on()
+ gutils.run_ttff(self.ad, mode="hs", criteria=self.xtra_hs_criteria,
+ test_cycle=self.ttff_test_cycle, base_lat_long=self.pixel_lab_location,
+ collect_logs=self.collect_logs)
+
+ def test_xtra_download_mobile_data(self):
+ """Verify XTRA/LTO data could be downloaded via mobile data.
+
+ Steps:
+ 1. Delete all GNSS aiding data.
+ 2. Get location fixed.
+ 3. Verify whether XTRA/LTO is downloaded and injected.
+ 4. Repeat Step 1. to Step 3. for 5 times.
+
+ Expected Results:
+ XTRA/LTO data is properly downloaded and injected via mobile data.
+ """
+ mobile_xtra_result_all = []
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
+ for i in range(1, 6):
+ begin_time = get_current_epoch_time()
+ gutils.process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
+ time.sleep(5)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ mobile_xtra_result = gutils.check_xtra_download(self.ad, begin_time)
+ self.ad.log.info("Iteration %d => %s" % (i, mobile_xtra_result))
+ mobile_xtra_result_all.append(mobile_xtra_result)
+ asserts.assert_true(all(mobile_xtra_result_all),
+ "Fail to Download and Inject XTRA/LTO File.")
+
+ def test_xtra_download_wifi(self):
+ """Verify XTRA/LTO data could be downloaded via WiFi.
+
+ Steps:
+ 1. Connect to WiFi.
+ 2. Delete all GNSS aiding data.
+ 3. Get location fixed.
+ 4. Verify whether XTRA/LTO is downloaded and injected.
+ 5. Repeat Step 2. to Step 4. for 5 times.
+
+ Expected Results:
+ XTRA data is properly downloaded and injected via WiFi.
+ """
+ wifi_xtra_result_all = []
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
+ self.connect_to_wifi_with_airplane_mode_on()
+ for i in range(1, 6):
+ begin_time = get_current_epoch_time()
+ gutils.process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
+ time.sleep(5)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ wifi_xtra_result = gutils.check_xtra_download(self.ad, begin_time)
+ wifi_xtra_result_all.append(wifi_xtra_result)
+ self.ad.log.info("Iteration %d => %s" % (i, wifi_xtra_result))
+ asserts.assert_true(all(wifi_xtra_result_all),
+ "Fail to Download and Inject XTRA/LTO File.")
+
+ def test_lto_download_after_reboot(self):
+ """Verify LTO data could be downloaded and injected after device reboot.
+
+ Steps:
+ 1. Reboot device.
+ 2. Verify whether LTO is auto downloaded and injected without trigger GPS.
+ 3. Repeat Step 1 to Step 2 for 5 times.
+
+ Expected Results:
+ LTO data is properly downloaded and injected at the first time tether to phone.
+ """
+ reboot_lto_test_results_all = []
+ for times in range(1, 6):
+ gutils.delete_lto_file(self.ad)
+ gutils.reboot(self.ad)
+ gutils.start_qxdm_and_tcpdump_log(self.ad, self.collect_logs)
+ # Wait 20 seconds for boot busy and lto auto-download time
+ time.sleep(20)
+ begin_time = get_current_epoch_time()
+ reboot_lto_test_result = gutils.check_xtra_download(self.ad, begin_time)
+ self.ad.log.info("Iteration %d => %s" % (times, reboot_lto_test_result))
+ reboot_lto_test_results_all.append(reboot_lto_test_result)
+ gutils.stop_pixel_logger(self.ad)
+ tel_logging_utils.stop_adb_tcpdump(self.ad)
+ asserts.assert_true(all(reboot_lto_test_results_all),
+ "Fail to Download and Inject LTO File.")
+
+ def test_ws_with_assist(self):
+ """Verify Warm Start functionality with existed LTO data.
+
+ Steps:
+ 2. Make LTO is downloaded.
+ 3. Turn on AirPlane mode to make sure there's no network connection.
+ 4. TTFF Warm Start with Assist for 10 iteration.
+
+ Expected Results:
+ All TTFF Warm Start with Assist results should be within
+ xtra_ws_criteria.
+ """
+ self.ttff_with_assist("ws", self.xtra_ws_criteria)
+
+ def test_cs_with_assist(self):
+ """Verify Cold Start functionality with existed LTO data.
+
+ Steps:
+ 2. Make sure LTO is downloaded.
+ 3. Turn on AirPlane mode to make sure there's no network connection.
+ 4. TTFF Cold Start with Assist for 10 iteration.
+
+ Expected Results:
+ All TTFF Cold Start with Assist results should be within
+ standalone_cs_criteria.
+ """
+ self.ttff_with_assist("csa", self.standalone_cs_criteria)
diff --git a/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py b/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py
index 0604c65..a90a01f 100644
--- a/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py
+++ b/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py
@@ -14,15 +14,16 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import time
+import statistics
from acts import asserts
from acts import signals
from acts.base_test import BaseTestClass
-from acts.test_decorators import test_tracker_info
+from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid
from acts_contrib.test_utils.gnss import gnss_test_utils as gutils
-from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.tel import tel_logging_utils as tutils
from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection
+from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode
from acts.utils import get_current_epoch_time
from acts_contrib.test_utils.gnss.gnss_test_utils import delete_lto_file, pair_to_wearable
from acts_contrib.test_utils.gnss.gnss_test_utils import process_gnss_by_gtw_gpstool
@@ -33,57 +34,56 @@
class GnssWearableTetherFunctionTest(BaseTestClass):
""" GNSS Wearable Tether Function Tests"""
-
def setup_class(self):
super().setup_class()
self.watch = self.android_devices[0]
self.phone = self.android_devices[1]
self.phone.uia = Device(self.phone.serial)
- req_params = [
- "pixel_lab_network", "standalone_cs_criteria",
- "flp_ttff_max_threshold", "pixel_lab_location", "flp_ttff_cycle",
- "default_gnss_signal_attenuation", "flp_waiting_time",
- "tracking_test_time", "fast_start_criteria"
- ]
+ req_params = ["pixel_lab_network", "standalone_cs_criteria",
+ "flp_ttff_max_threshold", "pixel_lab_location",
+ "flp_ttff_cycle", "default_gnss_signal_attenuation",
+ "flp_waiting_time", "tracking_test_time",
+ "far_start_criteria", "ttff_test_cycle"]
self.unpack_userparams(req_param_names=req_params)
# create hashmap for SSID
self.ssid_map = {}
for network in self.pixel_lab_network:
SSID = network["SSID"]
self.ssid_map[SSID] = network
- self.ttff_mode = {
- "cs": "Cold Start",
- "ws": "Warm Start",
- "hs": "Hot Start"
- }
+ self.ttff_mode = {"cs": "Cold Start",
+ "ws": "Warm Start",
+ "hs": "Hot Start"}
gutils._init_device(self.watch)
pair_to_wearable(self.watch, self.phone)
+ def teardown_class(self):
+ super().teardown_class()
+ gutils.reboot(self.phone)
+
def setup_test(self):
+ gutils.log_current_epoch_time(self.watch, "test_start_time")
+ log_testtracker_uuid(self.watch, self.current_test_name)
gutils.get_baseband_and_gms_version(self.watch)
gutils.clear_logd_gnss_qxdm_log(self.watch)
gutils.clear_logd_gnss_qxdm_log(self.phone)
gutils.set_attenuator_gnss_signal(self.watch, self.attenuators,
self.default_gnss_signal_attenuation)
- if not gutils.is_mobile_data_on(self.watch):
- gutils.set_mobile_data(self.watch, True)
- # TODO (b/202101058:chenstanley): Need to double check how to disable wifi successfully in wearable projects.
- if gutils.is_wearable_btwifi(self.watch):
- wutils.wifi_toggle_state(self.watch, True)
- gutils.connect_to_wifi_network(
- self.watch, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
- if not verify_internet_connection(
- self.watch.log, self.watch, retries=3, expected_state=True):
- raise signals.TestFailure(
- "Fail to connect to LTE or WiFi network.")
- if not gutils.is_bluetooth_connected(self.watch, self.phone):
- gutils.pair_to_wearable(self.phone, self.watch)
+ if not verify_internet_connection(self.watch.log, self.watch, retries=5,
+ expected_state=True):
+ time.sleep(60)
+ if not verify_internet_connection(self.watch.log, self.watch, retries=3,
+ expected_state=True):
+ raise signals.TestFailure("Fail to connect to LTE network.")
def teardown_test(self):
gutils.stop_pixel_logger(self.watch)
tutils.stop_adb_tcpdump(self.watch)
gutils.set_attenuator_gnss_signal(self.watch, self.attenuators,
- self.default_gnss_signal_attenuation)
+ self.default_gnss_signal_attenuation)
+ if self.watch.droid.connectivityCheckAirplaneMode():
+ self.watch.log.info("Force airplane mode off")
+ toggle_airplane_mode(self.watch.log, self.watch, new_state=False)
+ gutils.log_current_epoch_time(self.watch, "test_end_time")
def on_fail(self, test_name, begin_time):
self.watch.take_bug_report(test_name, begin_time)
@@ -97,64 +97,44 @@
def flp_ttff(self, mode, criteria, location):
self.start_qxdm_and_tcpdump_log()
- start_gnss_by_gtw_gpstool(self.phone, True, type="FLP")
+ start_gnss_by_gtw_gpstool(self.phone, True, api_type="FLP")
time.sleep(self.flp_waiting_time)
self.watch.unlock_screen(password=None)
begin_time = get_current_epoch_time()
- process_gnss_by_gtw_gpstool(self.watch,
- self.standalone_cs_criteria,
- type="flp")
- gutils.start_ttff_by_gtw_gpstool(self.watch,
- mode,
- iteration=self.flp_ttff_cycle)
- results = gutils.process_ttff_by_gtw_gpstool(self.watch,
- begin_time,
- location,
- type="flp")
+ process_gnss_by_gtw_gpstool(
+ self.watch, self.standalone_cs_criteria, api_type="flp")
+ gutils.start_ttff_by_gtw_gpstool(
+ self.watch, mode, iteration=self.flp_ttff_cycle)
+ results = gutils.process_ttff_by_gtw_gpstool(
+ self.watch, begin_time, location, api_type="flp")
gutils.check_ttff_data(self.watch, results, mode, criteria)
self.check_location_from_phone()
- start_gnss_by_gtw_gpstool(self.phone, False, type="FLP")
+ start_gnss_by_gtw_gpstool(self.phone, False, api_type="FLP")
def check_location_from_phone(self):
watch_file = check_tracking_file(self.watch)
phone_file = check_tracking_file(self.phone)
- return gutils.compare_watch_phone_location(self, watch_file,
- phone_file)
+ return gutils.compare_watch_phone_location(self, watch_file, phone_file)
+
+ def run_ttff_via_gtw_gpstool(self, mode, criteria):
+ """Run GNSS TTFF test with selected mode and parse the results.
+
+ Args:
+ mode: "cs", "ws" or "hs"
+ criteria: Criteria for the TTFF.
+ """
+ begin_time = get_current_epoch_time()
+ gutils.process_gnss_by_gtw_gpstool(self.watch, self.standalone_cs_criteria, clear_data=False)
+ gutils.start_ttff_by_gtw_gpstool(self.watch, mode, self.ttff_test_cycle)
+ ttff_data = gutils.process_ttff_by_gtw_gpstool(
+ self.watch, begin_time, self.pixel_lab_location)
+ result = gutils.check_ttff_data(
+ self.watch, ttff_data, self.ttff_mode.get(mode), criteria)
+ asserts.assert_true(
+ result, "TTFF %s fails to reach designated criteria of %d "
+ "seconds." % (self.ttff_mode.get(mode), criteria))
""" Test Cases """
-
- @test_tracker_info(uuid="2c62183a-4354-4efc-92f2-84580cbd3398")
- def test_lto_download_after_reboot(self):
- """Verify LTO data could be downloaded and injected after device reboot.
-
- Steps:
- 1. Reboot device.
- 2. Verify whether LTO is auto downloaded and injected without trigger GPS.
- 3. Repeat Step 1 to Step 2 for 5 times.
-
- Expected Results:
- LTO data is properly downloaded and injected at the first time tether to phone.
- """
- reboot_lto_test_results_all = []
- gutils.disable_supl_mode(self.watch)
- for times in range(1, 6):
- delete_lto_file(self.watch)
- gutils.reboot(self.watch)
- self.start_qxdm_and_tcpdump_log()
- # Wait 20 seconds for boot busy and lto auto-download time
- time.sleep(20)
- begin_time = get_current_epoch_time()
- reboot_lto_test_result = gutils.check_xtra_download(
- self.watch, begin_time)
- self.watch.log.info("Iteration %d => %s" %
- (times, reboot_lto_test_result))
- reboot_lto_test_results_all.append(reboot_lto_test_result)
- gutils.stop_pixel_logger(self.watch)
- tutils.stop_adb_tcpdump(self.watch)
- asserts.assert_true(all(reboot_lto_test_results_all),
- "Fail to Download and Inject LTO File.")
-
- @test_tracker_info(uuid="7ed596df-df71-42ca-bdb3-69a3cad81963")
def test_flp_ttff_cs(self):
"""Verify FLP TTFF Cold Start while tether with phone.
@@ -168,10 +148,8 @@
flp_ttff_max_threshold.
2. Watch uses phone's FLP location.
"""
- self.flp_ttff("cs", self.flp_ttff_max_threshold,
- self.pixel_lab_location)
+ self.flp_ttff("cs", self.flp_ttff_max_threshold, self.pixel_lab_location)
- @test_tracker_info(uuid="de19617c-1f03-4077-99af-542b300ab4ed")
def test_flp_ttff_ws(self):
"""Verify FLP TTFF Warm Start while tether with phone.
@@ -185,10 +163,8 @@
flp_ttff_max_threshold.
2. Watch uses phone's FLP location.
"""
- self.flp_ttff("ws", self.flp_ttff_max_threshold,
- self.pixel_lab_location)
+ self.flp_ttff("ws", self.flp_ttff_max_threshold, self.pixel_lab_location)
- @test_tracker_info(uuid="c58c90ae-9f4a-4619-a9f8-f2f98c930008")
def test_flp_ttff_hs(self):
"""Verify FLP TTFF Hot Start while tether with phone.
@@ -202,10 +178,8 @@
flp_ttff_max_threshold.
2. Watch uses phone's FLP location.
"""
- self.flp_ttff("hs", self.flp_ttff_max_threshold,
- self.pixel_lab_location)
+ self.flp_ttff("hs", self.flp_ttff_max_threshold, self.pixel_lab_location)
- @test_tracker_info(uuid="ca955ad3-e2eb-4fde-af2b-3e19abe47792")
def test_tracking_during_bt_disconnect_resume(self):
"""Verify tracking is correct during Bluetooth disconnect and resume.
@@ -222,18 +196,17 @@
2. Tracking results should be within pixel_lab_location criteria.
"""
self.start_qxdm_and_tcpdump_log()
- for i in range(1, 6):
+ for i in range(1, 4):
if not self.watch.droid.bluetoothCheckState():
self.watch.droid.bluetoothToggleState(True)
self.watch.log.info("Turn Bluetooth on")
- self.watch.log.info("Wait 1 min for Bluetooth auto re-connect")
- time.sleep(60)
- if not gutils.is_bluetooth_connect(self.watch, self.phone):
- raise signals.TestFailure(
- "Fail to connect to device via Bluetooth.")
- start_gnss_by_gtw_gpstool(self.phone, True, type="FLP")
+ self.watch.log.info("Wait 40s for Bluetooth auto re-connect")
+ time.sleep(40)
+ if not gutils.is_bluetooth_connected(self.watch, self.phone):
+ raise signals.TestFailure("Fail to connect to device via Bluetooth.")
+ start_gnss_by_gtw_gpstool(self.phone, True, api_type="FLP")
time.sleep(self.flp_waiting_time)
- start_gnss_by_gtw_gpstool(self.watch, True, type="FLP")
+ start_gnss_by_gtw_gpstool(self.watch, True, api_type="FLP")
time.sleep(self.flp_waiting_time)
self.watch.log.info("Wait 1 min for tracking")
time.sleep(self.tracking_test_time)
@@ -245,14 +218,11 @@
time.sleep(self.tracking_test_time)
if self.check_location_from_phone():
raise signals.TestError("Watch should not use phone location")
- gutils.parse_gtw_gpstool_log(self.watch,
- self.pixel_lab_location,
- type="FLP")
- start_gnss_by_gtw_gpstool(self.phone, False, type="FLP")
+ gutils.parse_gtw_gpstool_log(self.watch, self.pixel_lab_location, api_type="FLP")
+ start_gnss_by_gtw_gpstool(self.phone, False, api_type="FLP")
- @test_tracker_info(uuid="654a8f1b-f9c6-433e-a21f-59224cce822e")
- def test_fast_start_first_fix_and_ttff(self):
- """Verify first fix and TTFF of Fast Start (Warm Start v4) within the criteria
+ def test_oobe_first_fix(self):
+ """Verify first fix after OOBE pairing within the criteria
Steps:
1. Pair watch to phone during OOBE.
@@ -261,33 +231,78 @@
4. Enable AirPlane mode to untether to phone.
5. Open GPSTool to get first fix in LTO and UTC time injected.
6. Repeat Step1 ~ Step5 for 5 times.
- 7. After Step6, Warm Start TTFF for 10 iterations.
Expected Results:
- 1. First fix should be within fast_start_threshold.
- 2. TTFF should be within fast_start_threshold.
+ 1. First fix should be within far_start_threshold.
"""
- for i in range(1, 6):
- self.watch.log.info("First fix of Fast Start - attempts %s" % i)
+ oobe_results_all = []
+ for i in range(1,4):
+ self.watch.log.info("First fix after OOBE pairing - attempts %s" % i)
pair_to_wearable(self.watch, self.phone)
- gutils.enable_framework_log(self.watch)
self.start_qxdm_and_tcpdump_log()
begin_time = get_current_epoch_time()
gutils.check_xtra_download(self.watch, begin_time)
gutils.check_inject_time(self.watch)
self.watch.log.info("Turn airplane mode on")
- self.watch.droid.connectivityToggleAirplaneMode(True)
- self.watch.unlock_screen(password=None)
- gutils.process_gnss_by_gtw_gpstool(self.watch,
- self.fast_start_criteria,
- clear_data=False)
- gutils.start_ttff_by_gtw_gpstool(self.watch,
- ttff_mode="ws",
- iteration=self.ttff_test_cycle)
- ttff_data = gutils.process_ttff_by_gtw_gpstool(self.watch, begin_time,
- self.pixel_lab_location)
- result = gutils.check_ttff_data(self.watch,
- ttff_data,
- self.ttff_mode.get("ws"),
- criteria=self.fast_start_criteria)
- asserts.assert_true(result, "TTFF fails to reach designated criteria")
+ # self.watch.droid.connectivityToggleAirplaneMode(True)
+ toggle_airplane_mode(self.watch.log, self.watch, new_state=True)
+ oobe_results = gutils.process_gnss(
+ self.watch, self.far_start_criteria, clear_data=False)
+ oobe_results_all.append(oobe_results)
+ self.watch.log.info(f"TestResult Max_OOBE_First_Fix {max(oobe_results_all)}")
+ self.watch.log.info(f"TestResult Avg_OOBE_First_Fix {statistics.mean(oobe_results_all)}")
+ # self.watch.droid.connectivityToggleAirplaneMode(False)
+ toggle_airplane_mode(self.watch.log, self.watch, new_state=False)
+ self.watch.log.info("Turn airplane mode off")
+
+ def test_oobe_first_fix_with_network_connection(self):
+ """Verify first fix after OOBE pairing within the criteria
+
+ Steps:
+ 1. Pair watch to phone during OOBE.
+ 2. Ensure LTO file download in watch.
+ 3. Ensure UTC time inject in watch.
+ 4. Turn off Bluetooth to untether to phone.
+ 5. Open GPSTool to get first fix in LTO and UTC time injected.
+ 6. Repeat Step1 ~ Step5 for 5 times.
+
+ Expected Results:
+ 1. First fix should be within far_start_threshold.
+ """
+ oobe_results_all = []
+ for i in range(1,4):
+ self.watch.log.info("First fix after OOBE pairing - attempts %s" % i)
+ pair_to_wearable(self.watch, self.phone)
+ self.start_qxdm_and_tcpdump_log()
+ begin_time = get_current_epoch_time()
+ gutils.check_xtra_download(self.watch, begin_time)
+ gutils.check_inject_time(self.watch)
+ self.watch.log.info("Turn off Bluetooth to disconnect to phone")
+ self.watch.droid.bluetoothToggleState(False)
+ oobe_results = gutils.process_gnss(
+ self.watch, self.far_start_criteria, clear_data=False)
+ oobe_results_all.append(oobe_results)
+ self.watch.log.info(f"TestResult Max_OOBE_First_Fix {max(oobe_results_all)}")
+ self.watch.log.info(f"TestResult Avg_OOBE_First_Fix {statistics.mean(oobe_results_all)}")
+
+ def test_far_start_ttff(self):
+ """Verify Far Start (Warm Start v4) TTFF within the criteria
+
+ Steps:
+ 1. Pair watch to phone during OOBE.
+ 2. Ensure LTO file download in watch.
+ 3. Ensure UTC time inject in watch.
+ 4. Enable AirPlane mode to untether to phone.
+ 5. TTFF Warm Start for 10 iteration.
+
+ Expected Results:
+ 1. TTFF should be within far_start_threshold.
+ """
+ pair_to_wearable(self.watch, self.phone)
+ self.start_qxdm_and_tcpdump_log()
+ begin_time = get_current_epoch_time()
+ gutils.check_xtra_download(self.watch, begin_time)
+ gutils.check_inject_time(self.watch)
+ self.watch.log.info("Turn airplane mode on")
+ toggle_airplane_mode(self.watch.log, self.watch, new_state=True)
+ self.run_ttff_via_gtw_gpstool("ws", self.far_start_criteria)
diff --git a/acts_tests/tests/google/gnss/LabGnssPowerSweepTest.py b/acts_tests/tests/google/gnss/LabGnssPowerSweepTest.py
new file mode 100644
index 0000000..f641cc4
--- /dev/null
+++ b/acts_tests/tests/google/gnss/LabGnssPowerSweepTest.py
@@ -0,0 +1,324 @@
+#!/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 os
+from acts_contrib.test_utils.gnss.GnssBlankingBase import GnssBlankingBase
+from collections import namedtuple
+from acts_contrib.test_utils.gnss.LabTtffTestBase import LabTtffTestBase
+from acts_contrib.test_utils.gnss.gnss_test_utils import detect_crash_during_tracking, gnss_tracking_via_gtw_gpstool, \
+ start_gnss_by_gtw_gpstool, process_ttff_by_gtw_gpstool, calculate_position_error
+from acts.context import get_current_context
+from acts.utils import get_current_epoch_time
+from time import sleep
+import csv
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d.axes3d import Axes3D
+import statistics
+
+
+class LabGnssPowerSweepTest(GnssBlankingBase):
+
+ def gnss_plot_2D_result(self, position_error):
+ """Plot 2D position error result
+ """
+ x_axis = []
+ y_axis = []
+ z_axis = []
+ for key in position_error:
+ tmp = key.split('_')
+ l1_pwr = float(tmp[1])
+ l5_pwr = float(tmp[3])
+ position_error_value = position_error[key]
+ x_axis.append(l1_pwr)
+ y_axis.append(l5_pwr)
+ z_axis.append(position_error_value)
+
+ fig = plt.figure(figsize=(12, 7))
+ ax = plt.axes(projection='3d')
+ ax.scatter(x_axis, y_axis, z_axis)
+ plt.title("Z axis Position Error", fontsize=12)
+ plt.xlabel("L1 PWR (dBm)", fontsize=12)
+ plt.ylabel("L5 PWR (dBm)", fontsize=12)
+ plt.show()
+ path_name = os.path.join(self.gnss_log_path, 'result.png')
+ plt.savefig(path_name)
+
+ def gnss_wait_for_ephemeris_download(self):
+ """Launch GTW GPSTool and Clear all GNSS aiding data
+ Start GNSS tracking on GTW_GPSTool.
+ Wait for "first_wait" at simulator power = "power_level" to download Ephemeris
+ """
+ first_wait = self.user_params.get('first_wait', 300)
+ LabTtffTestBase.start_set_gnss_power(self)
+ self.start_gnss_and_wait(first_wait)
+
+ def gnss_check_fix(self, json_tag):
+ """Launch GTW GPSTool and check position fix or not
+ Returns:
+ True : Can fix within 120 sec
+ False
+ """
+ # Check Latitude for fix
+ self.dut.log.info("Restart GTW GPSTool in gnss_check_fix")
+ start_gnss_by_gtw_gpstool(self.dut, state=True)
+ begin_time = get_current_epoch_time()
+ if not self.dut.is_adb_logcat_on:
+ self.dut.start_adb_logcat()
+ while True:
+ if get_current_epoch_time() - begin_time >= 120000:
+ self.dut.log.info("Location fix timeout in gnss_check_fix")
+ start_gnss_by_gtw_gpstool(self.dut, state=False)
+ json_tag = json_tag + '_gnss_check_fix_timeout'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return False
+ sleep(1)
+ logcat_results = self.dut.search_logcat("Latitude", begin_time)
+ if logcat_results:
+ self.dut.log.info("Location fix successfully in gnss_check_fix")
+ json_tag = json_tag + '_gnss_check_fix_success'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return True
+
+ def gnss_check_l5_engaging(self, json_tag):
+ """check L5 engaging
+ Returns:
+ True : L5 engaged
+ False
+ """
+ # Check L5 engaging rate
+ begin_time = get_current_epoch_time()
+ if not self.dut.is_adb_logcat_on:
+ self.dut.start_adb_logcat()
+ while True:
+ if get_current_epoch_time() - begin_time >= 120000:
+ self.dut.log.info(
+ "L5 engaging timeout in gnss_check_l5_engaging")
+ start_gnss_by_gtw_gpstool(self.dut, state=False)
+ json_tag = json_tag + '_gnss_check_l5_engaging_timeout'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return False
+ sleep(1)
+ logcat_results = self.dut.search_logcat("L5 engaging rate:",
+ begin_time)
+ if logcat_results:
+ start_idx = logcat_results[-1]['log_message'].find(
+ "L5 engaging rate:")
+ tmp = logcat_results[-1]['log_message'][(start_idx + 18):]
+ l5_engaging_rate = float(tmp.strip('%'))
+
+ if l5_engaging_rate != 0:
+ self.dut.log.info("L5 engaged")
+ json_tag = json_tag + '_gnss_check_l5_engaging_success'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return True
+
+ def gnss_check_position_error(self, json_tag):
+ """check position error
+ Returns:
+ position error average value
+ """
+ average_position_error_count = 60
+ position_error_all = []
+ hacc_all = []
+ default_position_error_mean = 6666
+ default_position_error_std = 6666
+ default_hacc_mean = 6666
+ default_hacc_std = 6666
+ idx = 0
+ begin_time = get_current_epoch_time()
+ if not self.dut.is_adb_logcat_on:
+ self.dut.start_adb_logcat()
+ while True:
+ if get_current_epoch_time() - begin_time >= 120000:
+ self.dut.log.info(
+ "Position error calculation timeout in gnss_check_position_error"
+ )
+ start_gnss_by_gtw_gpstool(self.dut, state=False)
+ json_tag = json_tag + '_gnss_check_position_error_timeout'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return default_position_error_mean, default_position_error_std, default_hacc_mean, default_hacc_std
+ sleep(1)
+ gnss_results = self.dut.search_logcat("GPSService: Check item",
+ begin_time)
+ if gnss_results:
+ self.dut.log.info(gnss_results[-1]["log_message"])
+ gnss_location_log = \
+ gnss_results[-1]["log_message"].split()
+ ttff_lat = float(gnss_location_log[8].split("=")[-1].strip(","))
+ ttff_lon = float(gnss_location_log[9].split("=")[-1].strip(","))
+ loc_time = int(gnss_location_log[10].split("=")[-1].strip(","))
+ ttff_haccu = float(
+ gnss_location_log[11].split("=")[-1].strip(","))
+ hacc_all.append(ttff_haccu)
+ position_error = calculate_position_error(
+ ttff_lat, ttff_lon, self.simulator_location)
+ position_error_all.append(abs(position_error))
+ idx = idx + 1
+ if idx >= average_position_error_count:
+ position_error_mean = statistics.mean(position_error_all)
+ position_error_std = statistics.stdev(position_error_all)
+ hacc_mean = statistics.mean(hacc_all)
+ hacc_std = statistics.stdev(hacc_all)
+ json_tag = json_tag + '_gnss_check_position_error_success'
+ self.dut.cat_adb_log(tag=json_tag,
+ begin_time=begin_time,
+ end_time=None,
+ dest_path=self.gnss_log_path)
+ return position_error_mean, position_error_std, hacc_mean, hacc_std
+
+ def gnss_tracking_L5_position_error_capture(self, json_tag):
+ """Capture position error after L5 engaged
+ Args:
+ Returns:
+ Position error with L5
+ """
+ self.dut.log.info('Start gnss_tracking_L5_position_error_capture')
+ fixed = self.gnss_check_fix(json_tag)
+ if fixed:
+ l5_engaged = self.gnss_check_l5_engaging(json_tag)
+ if l5_engaged:
+ position_error_mean, position_error_std, hacc_mean, hacc_std = self.gnss_check_position_error(
+ json_tag)
+ start_gnss_by_gtw_gpstool(self.dut, state=False)
+ else:
+ position_error_mean = 8888
+ position_error_std = 8888
+ hacc_mean = 8888
+ hacc_std = 8888
+ else:
+ position_error_mean = 9999
+ position_error_std = 9999
+ hacc_mean = 9999
+ hacc_std = 9999
+ self.position_fix_timeout_cnt = self.position_fix_timeout_cnt + 1
+
+ if self.position_fix_timeout_cnt > (self.l1_sweep_cnt / 2):
+ self.l1_sensitivity_point = self.current_l1_pwr
+
+ return position_error_mean, position_error_std, hacc_mean, hacc_std
+
+ def gnss_power_tracking_loop(self):
+ """Launch GTW GPSTool and Clear all GNSS aiding data
+ Start GNSS tracking on GTW_GPSTool.
+
+ Args:
+
+ Returns:
+ True: First fix TTFF are within criteria.
+ False: First fix TTFF exceed criteria.
+ """
+ test_period = 60
+ type = 'gnss'
+ start_time = get_current_epoch_time()
+ start_gnss_by_gtw_gpstool(self.dut, state=True, type=type)
+ while get_current_epoch_time() - start_time < test_period * 1000:
+ detect_crash_during_tracking(self.dut, start_time, type)
+ stop_time = get_current_epoch_time()
+
+ return start_time, stop_time
+
+ def parse_tracking_log_cat(self, log_dir):
+ self.log.warning(f'Parsing log cat {log_dir} results into dataframe!')
+
+ def check_l5_points(self, gnss_pwr_swp):
+ cnt = 0
+ for kk in range(len(gnss_pwr_swp[1])):
+ if gnss_pwr_swp[1][kk][0] == gnss_pwr_swp[1][kk + 1][0]:
+ cnt = cnt + 1
+ else:
+ return cnt
+
+ def test_tracking_power_sweep(self):
+ # Create log file path
+ full_output_path = get_current_context().get_full_output_path()
+ self.gnss_log_path = os.path.join(full_output_path, '')
+ os.makedirs(self.gnss_log_path, exist_ok=True)
+ self.log.debug(f'Create log path: {self.gnss_log_path}')
+ csv_path = self.gnss_log_path + 'L1_L5_2D_search_result.csv'
+ csvfile = open(csv_path, 'w')
+ writer = csv.writer(csvfile)
+ writer.writerow([
+ "csv_result_tag", "position_error_mean", "position_error_std",
+ "hacc_mean", "hacc_std"
+ ])
+ # for L1 position fix early termination
+ self.l1_sensitivity_point = -999
+ self.enable_early_terminate = 1
+ self.position_fix_timeout_cnt = 0
+ self.current_l1_pwr = 0
+ self.l1_sweep_cnt = 0
+
+ self.gnss_wait_for_ephemeris_download()
+ l1_cable_loss = self.gnss_sim_params.get('L1_cable_loss')
+ l5_cable_loss = self.gnss_sim_params.get('L5_cable_loss')
+
+ for i, gnss_pwr_swp in enumerate(self.gnss_pwr_sweep_fine_sweep_ls):
+ self.log.info(f'Start fine GNSS power level sweep part {i + 1}')
+ self.l1_sweep_cnt = self.check_l5_points(gnss_pwr_swp)
+ for gnss_pwr_params in gnss_pwr_swp[1]:
+ json_tag = f'test_'
+ csv_result_tag = ''
+ for ii, pwr in enumerate(
+ gnss_pwr_params): # Setup L1 and L5 power
+ sat_sys = gnss_pwr_swp[0][ii].get('sat').upper()
+ band = gnss_pwr_swp[0][ii].get('band').upper()
+ if band == "L1":
+ pwr_biased = pwr + l1_cable_loss
+ if pwr != self.current_l1_pwr:
+ self.position_fix_timeout_cnt = 0
+ self.current_l1_pwr = pwr
+ elif band == "L5":
+ pwr_biased = pwr + l5_cable_loss
+ else:
+ pwr_biased = pwr
+ # Set GNSS Simulator power level
+ self.gnss_simulator.ping_inst()
+ self.gnss_simulator.set_scenario_power(
+ power_level=pwr_biased,
+ sat_system=sat_sys,
+ freq_band=band)
+ self.log.info(f'Set {sat_sys} {band} with power {pwr}')
+ json_tag = json_tag + f'{sat_sys}_{band}_{pwr}'
+ csv_result_tag = csv_result_tag + f'{band}_{pwr}_'
+
+ if self.current_l1_pwr < self.l1_sensitivity_point and self.enable_early_terminate == 1:
+ position_error_mean = -1
+ position_error_std = -1
+ hacc_mean = -1
+ hacc_std = -1
+ else:
+ position_error_mean, position_error_std, hacc_mean, hacc_std = self.gnss_tracking_L5_position_error_capture(
+ json_tag)
+ writer = csv.writer(csvfile)
+ writer.writerow([
+ csv_result_tag, position_error_mean, position_error_std,
+ hacc_mean, hacc_std
+ ])
+ csvfile.close()
diff --git a/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py b/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py
index 24da4d3..664c5b6 100644
--- a/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py
+++ b/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py
@@ -16,7 +16,8 @@
from acts_contrib.test_utils.gnss import LabTtffTestBase as lttb
from acts_contrib.test_utils.gnss.gnss_test_utils import launch_eecoexer
-from acts_contrib.test_utils.gnss.gnss_test_utils import excute_eecoexer_function
+from acts_contrib.test_utils.gnss.gnss_test_utils import execute_eecoexer_function
+
class LabTtffGeneralCoexTest(lttb.LabTtffTestBase):
@@ -26,6 +27,8 @@
super().setup_class()
req_params = ['coex_testcase_ls']
self.unpack_userparams(req_param_names=req_params)
+ self.test_cmd = ''
+ self.stop_cmd = ''
def setup_test(self):
super().setup_test()
@@ -34,16 +37,9 @@
self.dut.adb.shell(
'setprop persist.com.google.eecoexer.cellular.temperature_limit 60')
- def exe_eecoexer_loop_cmd(self, cmd_list=list()):
- """
- Function for execute EECoexer command list
- Args:
- cmd_list: a list of EECoexer function command.
- Type, list.
- """
- for cmd in cmd_list:
- self.log.info('Execute EEcoexer Command: {}'.format(cmd))
- excute_eecoexer_function(self.dut, cmd)
+ def teardown_test(self):
+ super().teardown_test()
+ self.exe_eecoexer_loop_cmd(self.stop_cmd)
def gnss_ttff_ffpe_coex_base(self, mode):
"""
@@ -54,29 +50,35 @@
cs(cold start), ws(warm start), hs(hot start)
"""
# Loop all test case in coex_testcase_ls
- for test_item in self.coex_testcase_ls:
+ for i, test_item in enumerate(self.coex_testcase_ls):
+
+ if i > 0:
+ self.setup_test()
# get test_log_path from coex_testcase_ls['test_name']
test_log_path = test_item['test_name']
# get test_cmd from coex_testcase_ls['test_cmd']
- test_cmd = test_item['test_cmd']
+ self.test_cmd = test_item['test_cmd']
# get stop_cmd from coex_testcase_ls['stop_cmd']
- stop_cmd = test_item['stop_cmd']
+ self.stop_cmd = test_item['stop_cmd']
# Start aggressor Tx by EEcoexer
- self.exe_eecoexer_loop_cmd(test_cmd)
+ # self.exe_eecoexer_loop_cmd(test_cmd)
# Start GNSS TTFF FFPE testing
- self.gnss_ttff_ffpe(mode, test_log_path)
+ self.gnss_ttff_ffpe(mode, test_log_path, self.test_cmd, self.stop_cmd)
# Stop aggressor Tx by EEcoexer
- self.exe_eecoexer_loop_cmd(stop_cmd)
+ # self.exe_eecoexer_loop_cmd(stop_cmd)
# Clear GTW GPSTool log. Need to clean the log every round of the test.
self.clear_gps_log()
+ if i < len(self.coex_testcase_ls) - 1:
+ self.teardown_test()
+
def test_gnss_cold_ttff_ffpe_coex(self):
"""
Cold start TTFF and FFPE GNSS general coex testing
diff --git a/acts_tests/tests/google/gnss/LocationPlatinumTest.py b/acts_tests/tests/google/gnss/LocationPlatinumTest.py
index 6f4c253..a50acb4 100644
--- a/acts_tests/tests/google/gnss/LocationPlatinumTest.py
+++ b/acts_tests/tests/google/gnss/LocationPlatinumTest.py
@@ -67,7 +67,7 @@
gutils.check_location_service(self.ad)
if not self.ad.droid.wifiCheckState():
wutils.wifi_toggle_state(self.ad, True)
- gutils.connect_to_wifi_network(self.ad, self.wifi_network)
+ gutils.connect_to_wifi_network(self.ad, self.wifi_network)
def get_and_verify_ttff(self, mode):
"""Retrieve ttff with designate mode.
diff --git a/acts_tests/tests/google/power/bt/PowerBLEadvertiseTest.py b/acts_tests/tests/google/power/bt/PowerBLEadvertiseTest.py
index 4f42ae0..27fca6b 100644
--- a/acts_tests/tests/google/power/bt/PowerBLEadvertiseTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBLEadvertiseTest.py
@@ -25,6 +25,7 @@
class PowerBLEadvertiseTest(PBtBT.PowerBTBaseTest):
+
def __init__(self, configs):
super().__init__(configs)
req_params = ['adv_modes', 'adv_power_levels']
@@ -32,7 +33,9 @@
# Loop all advertise modes and power levels
for adv_mode in self.adv_modes:
for adv_power_level in self.adv_power_levels:
- self.generate_test_case(adv_mode, adv_power_level)
+ # As a temporary fix, set high power tests directly
+ if adv_power_level != 3:
+ self.generate_test_case(adv_mode, adv_power_level)
def setup_class(self):
@@ -58,3 +61,12 @@
self.adv_duration)
time.sleep(EXTRA_ADV_TIME)
self.measure_power_and_validate()
+
+ def test_BLE_ADVERTISE_MODE_LOW_POWER_TX_POWER_HIGH(self):
+ self.measure_ble_advertise_power(0, 3)
+
+ def test_BLE_ADVERTISE_MODE_BALANCED_TX_POWER_HIGH(self):
+ self.measure_ble_advertise_power(1, 3)
+
+ def test_BLE_ADVERTISE_MODE_LOW_LATENCY_TX_POWER_HIGH(self):
+ self.measure_ble_advertise_power(2, 3)
diff --git a/acts_tests/tests/google/power/bt/PowerBLEscanTest.py b/acts_tests/tests/google/power/bt/PowerBLEscanTest.py
index 0aa5ad9..f76f796 100644
--- a/acts_tests/tests/google/power/bt/PowerBLEscanTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBLEscanTest.py
@@ -30,9 +30,6 @@
req_params = ['scan_modes']
self.unpack_userparams(req_params)
- for scan_mode in self.scan_modes:
- self.generate_test_case_no_devices_around(scan_mode)
-
def setup_class(self):
super().setup_class()
@@ -54,3 +51,12 @@
btputils.start_apk_ble_scan(self.dut, scan_mode, self.scan_duration)
time.sleep(EXTRA_SCAN_TIME)
self.measure_power_and_validate()
+
+ def test_BLE_SCAN_MODE_LOW_POWER_no_advertisers(self):
+ self.measure_ble_scan_power(0)
+
+ def test_BLE_SCAN_MODE_BALANCED_no_advertisers(self):
+ self.measure_ble_scan_power(1)
+
+ def test_BLE_SCAN_MODE_LOW_LATENCY_no_advertisers(self):
+ self.measure_ble_scan_power(2)
diff --git a/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py b/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
index 419c418..7c882bd 100644
--- a/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
@@ -39,7 +39,9 @@
# Loop all codecs and tx power levels
for codec_config in self.codecs:
for tpl in self.tx_power_levels:
- self.generate_test_case(codec_config, tpl)
+ # As a temporary fix, directly set the test with tpl 10
+ if tpl != 10:
+ self.generate_test_case(codec_config, tpl)
def setup_test(self):
super().setup_test()
@@ -107,3 +109,9 @@
codec_config['codec_type'], tpl))
self.dut.droid.goToSleepNow()
self.measure_power_and_validate()
+
+ def test_BTa2dp_AAC_codec_at_EPA_BF(self):
+ self.measure_a2dp_power(self.codecs[0], 10)
+
+ def test_BTa2dp_SBC_codec_at_EPA_BF(self):
+ self.measure_a2dp_power(self.codecs[1], 10)
\ No newline at end of file
diff --git a/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py b/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
index c0bac23..db92276 100644
--- a/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
@@ -73,3 +73,9 @@
with open(self.log_file, 'w', newline='') as f:
writer = csv.writer(f)
writer.writerows(self.cal_matrix)
+
+ def teardown_test(self):
+ """
+ Clean up in teardown_test : Disable BQR
+ """
+ btutils.disable_bqr(self.dut)
diff --git a/acts_tests/tests/google/power/tel/PowerTelAirplaneMode_Test.py b/acts_tests/tests/google/power/tel/PowerTelAirplaneMode_Test.py
new file mode 100644
index 0000000..44fab02
--- /dev/null
+++ b/acts_tests/tests/google/power/tel/PowerTelAirplaneMode_Test.py
@@ -0,0 +1,36 @@
+# Copyright 2022 - 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 acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
+
+
+class PowerTelAirplaneModeTest(PB.PowerCellularPresetLabBaseTest):
+
+ def power_tel_airplane_mode_test(self):
+ """Measure power while airplane mode is on. """
+ # Start airplane mode
+ self.cellular_dut.toggle_airplane_mode(True)
+
+ # Allow airplane mode to propagate
+ time.sleep(3)
+
+ # Measure power
+ self.collect_power_data()
+ # Check if power measurement is within the required values
+ self.pass_fail_check(self.avg_current)
+
+class PowerTelAirplaneMode_Test(PowerTelAirplaneModeTest):
+ def test_airplane_mode(self):
+ self.power_tel_airplane_mode_test()
\ No newline at end of file
diff --git a/acts_tests/tests/google/power/tel/PowerTelIdle_Preset_Test.py b/acts_tests/tests/google/power/tel/PowerTelIdle_Preset_Test.py
new file mode 100644
index 0000000..8efbc76
--- /dev/null
+++ b/acts_tests/tests/google/power/tel/PowerTelIdle_Preset_Test.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+#
+# Copyright 2022 - 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 acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
+
+
+class PowerTelIdle_Preset_Test(PB.PowerCellularPresetLabBaseTest):
+ def power_tel_idle_test(self):
+ """ Measures power when the device is on RRC idle state."""
+ idle_wait_time = self.simulation.rrc_sc_timer + 30
+ # Wait for RRC status change to trigger
+ self.cellular_simulator.wait_until_idle_state(idle_wait_time)
+
+ # Measure power
+ self.collect_power_data()
+
+ # Check if power measurement is below the required value
+ self.pass_fail_check(self.avg_current)
+
+ def test_preset_LTE_idle(self):
+ self.power_tel_idle_test()
+
+ def test_preset_sa_idle_fr1(self):
+ self.power_tel_idle_test()
diff --git a/acts_tests/tests/google/power/tel/PowerTelIms_Preset_Test.py b/acts_tests/tests/google/power/tel/PowerTelIms_Preset_Test.py
new file mode 100644
index 0000000..a18653d
--- /dev/null
+++ b/acts_tests/tests/google/power/tel/PowerTelIms_Preset_Test.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+#
+# Copyright 20022 - 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
+
+from acts_contrib.test_utils.power.cellular.ims_api_connector_utils import ImsApiConnector
+import acts_contrib.test_utils.power.cellular.cellular_power_base_test as PWCEL
+from acts_contrib.test_utils.tel.tel_test_utils import set_phone_silent_mode
+from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
+import acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
+
+
+class PowerTelImsPresetTest(PB.PowerCellularPresetLabBaseTest):
+ ADB_CMD_ENABLE_IMS = ('am broadcast '
+ '-a com.google.android.carrier.action.LOCAL_OVERRIDE '
+ '-n com.google.android.carrier/.ConfigOverridingReceiver '
+ '--ez carrier_volte_available_bool true '
+ '--ez carrier_wfc_ims_available_bool true '
+ '--ez carrier_vt_available_bool true '
+ '--ez carrier_supports_ss_over_ut_bool true '
+ '--ez vonr_setting_visibility_bool true '
+ '--ez vonr_enabled_bool true')
+
+ ADB_CMD_DISABLE_IMS = ('am broadcast '
+ '-a com.google.android.carrier.action.LOCAL_OVERRIDE '
+ '-n com.google.android.carrier/.ConfigOverridingReceiver '
+ '--ez carrier_volte_available_bool false '
+ '--ez carrier_wfc_ims_available_bool false '
+ '--ez carrier_vt_available_bool false '
+ '--ez carrier_supports_ss_over_ut_bool false '
+ '--ez vonr_setting_visibility_bool false '
+ '--ez vonr_enabled_bool false')
+
+ # set NV command
+ # !NRCAPA.Gen.VoiceOverNr, 0, 01
+ ADB_SET_GOOG_NV = 'echo at+googsetnv="{nv_name}",{index},"{value}" > /dev/umts_router'
+
+ # Key IMS simulator default value
+ IMS_CLIENT_DEFAULT_IP = '127.0.0.1'
+ IMS_CLIENT_DEFAULT_PORT = 8250
+ IMS_CLIENT_DEFAULT_API_TOKEN = 'myclient'
+ IMS_API_CONNECTOR_DEFAULT_PORT = 5050
+
+ # IMS available app
+ IMS_CLIENT = 'client'
+ IMS_SERVER = 'server'
+
+ def setup_class(self):
+ """ Executed only once when initializing the class. """
+ super().setup_class()
+
+ # disable mobile data
+ self.log.info('Disable mobile data.')
+ self.dut.adb.shell('svc data disable')
+
+ # Enable IMS on UE
+ self.log.info('Enable VoLTE using adb command.')
+ self.dut.adb.shell(self.ADB_CMD_ENABLE_IMS)
+
+ # reboot device for settings to update
+ self.log.info('Reboot for VoLTE settings to update.')
+ self.dut.reboot()
+
+ # Set voice call volume to minimum
+ set_phone_silent_mode(self.log, self.dut)
+
+ # initialize ims simulator connector wrapper
+ self.unpack_userparams(api_connector_port=self.IMS_API_CONNECTOR_DEFAULT_PORT,
+ api_token=self.IMS_CLIENT_DEFAULT_API_TOKEN,
+ ims_client_ip=self.IMS_CLIENT_DEFAULT_IP,
+ ims_client_port=self.IMS_CLIENT_DEFAULT_PORT)
+ self.ims_client = ImsApiConnector(
+ self.uxm_ip,
+ self.api_connector_port,
+ self.IMS_CLIENT,
+ self.api_token,
+ self.ims_client_ip,
+ self.ims_client_port,
+ self.log
+ )
+
+ def setup_test(self):
+ # Enable NR if it is VoNR test case
+ self.log.info(f'test name: {self.test_name}')
+ if 'NR' in self.test_name:
+ self.log.info('Enable VoNR for UE.')
+ self.enable_ims_nr()
+ super().setup_test()
+
+ def power_ims_call_test(self):
+ """ Measures power during a VoLTE call.
+
+ Measurement step in this test. Starts the voice call and
+ initiates power measurement. Pass or fail is decided with a
+ threshold value. """
+ # create dedicated bearer
+ self.log.info('create dedicated bearer.')
+ if 'LTE' in self.test_name:
+ self.cellular_simulator.create_dedicated_bearer()
+
+ time.sleep(5)
+
+ # Initiate the voice call
+ self.log.info('Callbox initiates call to UE.')
+ self.ims_client.initiate_call('001010123456789')
+
+ time.sleep(5)
+
+ # pick up call
+ self.log.info('UE pick up call.')
+ self.dut.adb.shell('input keyevent KEYCODE_CALL')
+
+ # Mute the call
+ self.dut.droid.telecomCallMute()
+
+ # Turn of screen
+ self.dut.droid.goToSleepNow()
+
+ # Measure power
+ self.collect_power_data()
+
+ # End the call
+ hangup_call(self.log, self.dut)
+
+ # Check if power measurement is within the required values
+ self.pass_fail_check()
+
+ def teardown_test(self):
+ super().teardown_test()
+ #self.cellular_simulator.deregister_ue_ims()
+ self.ims_client.remove_ims_app_link()
+
+ def teardown_class(self):
+ super().teardown_class()
+ self.log.info('Disable IMS.')
+ self.dut.adb.shell(self.ADB_CMD_DISABLE_IMS)
+
+
+class PowerTelIms_Preset_Test(PowerTelImsPresetTest):
+ def test_preset_LTE_voice(self):
+ self.power_ims_call_test()
+
+ def test_preset_NR_voice(self):
+ self.power_ims_call_test()
diff --git a/acts_tests/tests/google/power/tel/PowerTelPdcchFr2_Preset_Test.py b/acts_tests/tests/google/power/tel/PowerTelPdcchFr2_Preset_Test.py
new file mode 100644
index 0000000..3f023f3
--- /dev/null
+++ b/acts_tests/tests/google/power/tel/PowerTelPdcchFr2_Preset_Test.py
@@ -0,0 +1,36 @@
+# Copyright 2022 - 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 acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
+
+
+class PowerTelPdcchFr2_Preset_Test(PB.PowerCellularPresetLabBaseTest):
+ def power_pdcch_test(self):
+ """ Measures power during PDCCH only.
+
+ There's nothing to do here other than starting the power measurement
+ and deciding for pass or fail, as the base class will handle attaching.
+ Requirements for this test are that mac padding is off and that the
+ inactivity timer is not enabled. """
+
+ # Measure power
+ self.collect_power_data()
+
+ # Check if power measurement is within the required values
+ self.pass_fail_check(self.avg_current)
+
+ def test_preset_nsa_cdrx_fr2(self):
+ self.power_pdcch_test()
+
+ def test_preset_nsa_pdcch_fr2(self):
+ self.power_pdcch_test()
diff --git a/acts_tests/tests/google/power/tel/PowerTelPdcch_Preset_Test.py b/acts_tests/tests/google/power/tel/PowerTelPdcch_Preset_Test.py
index 1ee069a..2704638 100644
--- a/acts_tests/tests/google/power/tel/PowerTelPdcch_Preset_Test.py
+++ b/acts_tests/tests/google/power/tel/PowerTelPdcch_Preset_Test.py
@@ -11,26 +11,38 @@
# 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 acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
-from acts import context
-import acts_contrib.test_utils.power.cellular.cellular_pdcch_power_test as cppt
+class PowerTelPdcch_Preset_Test(PB.PowerCellularPresetLabBaseTest):
+ def power_pdcch_test(self):
+ """ Measures power during PDCCH only.
+ There's nothing to do here other than starting the power measurement
+ and deciding for pass or fail, as the base class will handle attaching.
+ Requirements for this test are that mac padding is off and that the
+ inactivity timer is not enabled. """
-class PowerTelPdcch_Preset_Test(cppt.PowerTelPDCCHTest):
- def test_preset_sa_pdcch(self):
+ # Measure power
+ self.collect_power_data()
+
+ # Check if power measurement is within the required values
+ self.pass_fail_check(self.avg_current)
+
+ def test_preset_sa_pdcch_fr1(self):
self.power_pdcch_test()
- def test_preset_nsa_pdcch(self):
+ def test_preset_nsa_pdcch_fr1(self):
self.power_pdcch_test()
def test_preset_LTE_pdcch(self):
self.power_pdcch_test()
- def test_preset_sa_cdrx(self):
+ def test_preset_sa_cdrx_fr1(self):
self.power_pdcch_test()
- def test_preset_nsa_cdrx(self):
+ def test_preset_nsa_cdrx_fr1(self):
self.power_pdcch_test()
def test_preset_LTE_cdrx(self):
self.power_pdcch_test()
+
diff --git a/acts_tests/tests/google/power/tel/PowerTelTraffic_Preset_Test.py b/acts_tests/tests/google/power/tel/PowerTelTraffic_Preset_Test.py
index ee30986..d05c801 100644
--- a/acts_tests/tests/google/power/tel/PowerTelTraffic_Preset_Test.py
+++ b/acts_tests/tests/google/power/tel/PowerTelTraffic_Preset_Test.py
@@ -11,22 +11,24 @@
# 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 os
+import time
-import paramiko
-import acts_contrib.test_utils.power.cellular.cellular_power_base_test as PWCEL
+import acts_contrib.test_utils.power.cellular.cellular_power_preset_base_test as PB
-class PowerTelTrafficPresetTest(PWCEL.PowerCellularLabBaseTest):
+class PowerTelTrafficPresetTest(PB.PowerCellularPresetLabBaseTest):
+ # command to enable mobile data
+ ADB_CMD_ENABLE_MOBILE_DATA = 'svc data enable'
+
# command to start iperf server on UE
START_IPERF_SV_UE_CMD = 'nohup > /dev/null 2>&1 sh -c "iperf3 -s -i1 -p5201 > /dev/null &"'
# command to start iperf server on UE
# (require: 1.path to iperf exe 2.hostname/hostIP)
- START_IPERF_CLIENT_UE_CMD = (
- 'nohup > /dev/null 2>&1 sh -c '
- '"iperf3 -c {iperf_host_ip} -i1 -p5202 -w8m -t2000 > /dev/null &"')
+ START_IPERF_CLIENT_UE_CMD = 'nohup > /dev/null 2>&1 sh -c "iperf3 -c {iperf_host_ip} -i1 -p5202 -w8m -t2000 > /dev/null &"'
- #command to start iperf server on host()
+ # command to start iperf server on host()
START_IPERF_SV_HOST_CMD = '{exe_path}\\iperf3 -s -p5202'
# command to start iperf client on host
@@ -34,58 +36,56 @@
START_IPERF_CLIENT_HOST_CMD = (
'{exe_path}\\iperf3 -c {ue_ip} -w16M -t1000 -p5201')
+ START_IPERF_CLIENT_HOST_CMD_FR2 = (
+ '{exe_path}\\iperf3 -c {ue_ip} -w16M -t1000 -p5201 -P32')
+
def __init__(self, controllers):
super().__init__(controllers)
self.ssh_iperf_client = None
self.ssh_iperf_server = None
+ self.iperf_out_err = {}
def setup_class(self):
super().setup_class()
# Unpack test parameters used in this class
- self.unpack_userparams(ssh_host_ip=None,
- host_username=None,
- client_ssh_private_key_file=None,
- iperf_exe_path=None,
+ self.unpack_userparams(iperf_exe_path=None,
ue_ip=None,
iperf_host_ip=None)
# Verify required config
- for param in ('ssh_host_ip', 'host_username', 'client_ssh_private_key_file',
- 'iperf_exe_path', 'ue_ip', 'iperf_host_ip'):
+ for param in ('iperf_exe_path', 'ue_ip', 'iperf_host_ip'):
if getattr(self, param) is None:
raise RuntimeError(
f'Parameter "{param}" is required to run this type of test')
def setup_test(self):
# Call parent method first to setup simulation
- if not super().setup_test():
- return False
+ super().setup_test()
# setup ssh client
- self.ssh_iperf_client = self._create_ssh_client()
- self.ssh_iperf_server = self._create_ssh_client()
+ self.ssh_iperf_client = self.cellular_simulator.create_ssh_client()
+ self.ssh_iperf_server = self.cellular_simulator.create_ssh_client()
+
+ self.turn_on_mobile_data()
def power_tel_traffic_test(self):
"""Measure power while data is transferring."""
# Start data traffic
- self.start_downlink_process()
self.start_uplink_process()
+ time.sleep(5)
+ self.start_downlink_process()
# Measure power
self.collect_power_data()
- def _create_ssh_client(self):
- """Create a ssh client to host."""
- ssh = paramiko.SSHClient()
- ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
- mykey = paramiko.Ed25519Key.from_private_key_file(
- self.client_ssh_private_key_file)
- ssh.connect(hostname=self.ssh_host_ip,
- username=self.host_username,
- pkey=mykey)
- self.log.info('SSH client to %s is connected' % self.ssh_host_ip)
- return ssh
+ # Write iperf log
+ self.ssh_iperf_server.close()
+ uplink_log_name = self.test_name + '_uplink.txt'
+ self._write_iperf_log(uplink_log_name, self.ssh_iperf_server)
+ self.ssh_iperf_client.close()
+ downlink_log_name = self.test_name + '_downlink.txt'
+ self._write_iperf_log(downlink_log_name, self.ssh_iperf_client)
def _exec_ssh_cmd(self, ssh_client, cmd):
"""Execute command on given ssh client.
@@ -95,24 +95,34 @@
cmd: command to execute via ssh.
"""
self.log.info('Sending cmd to ssh host: ' + cmd)
- stdin, _, _ = ssh_client.exec_command(cmd, get_pty=True)
+ stdin, stdout, stderr = ssh_client.exec_command(cmd, get_pty=True)
stdin.close()
- # TODO: stdout.readline cause program to hang
- # implement a workaround to getting response
- # from executed command
+ self.iperf_out_err[ssh_client] = (stdout, stderr)
def start_downlink_process(self):
"""UE transfer data to host."""
self.log.info('Start downlink process')
# start UE iperf server
self.cellular_dut.ad.adb.shell(self.START_IPERF_SV_UE_CMD)
+ self.log.info('cmd sent to UE: ' + self.START_IPERF_SV_UE_CMD)
self.log.info('UE iperf server started')
+ time.sleep(5)
# start host iperf client
- cmd = self.START_IPERF_CLIENT_HOST_CMD.format(
- exe_path=self.iperf_exe_path,
- ue_ip=self.ue_ip)
+ cmd = None
+ if 'fr2' in self.test_name:
+ cmd = self.START_IPERF_CLIENT_HOST_CMD_FR2.format(
+ exe_path=self.iperf_exe_path,
+ ue_ip=self.ue_ip)
+ else:
+ cmd = self.START_IPERF_CLIENT_HOST_CMD.format(
+ exe_path=self.iperf_exe_path,
+ ue_ip=self.ue_ip)
+
+ if not cmd:
+ raise RuntimeError('Cannot format command to start iperf client.')
self._exec_ssh_cmd(self.ssh_iperf_client, cmd)
self.log.info('Host iperf client started')
+ time.sleep(5)
def start_uplink_process(self):
"""Host transfer data to UE."""
@@ -121,13 +131,48 @@
cmd = self.START_IPERF_SV_HOST_CMD.format(exe_path=self.iperf_exe_path)
self._exec_ssh_cmd(self.ssh_iperf_server, cmd)
self.log.info('Host iperf server started')
+ time.sleep(5)
# start UE iperf
- self.cellular_dut.ad.adb.shell(
- self.START_IPERF_CLIENT_UE_CMD.format(iperf_host_ip=self.iperf_host_ip))
+ adb_cmd = self.START_IPERF_CLIENT_UE_CMD.format(
+ iperf_host_ip=self.iperf_host_ip)
+ self.cellular_dut.ad.adb.shell(adb_cmd)
+ self.log.info('cmd sent to UE: ' + adb_cmd)
self.log.info('UE iperf client started')
+ time.sleep(5)
+
+ def _write_iperf_log(self, file_name, ssh):
+ """ Writing ssh stdout and stdin to log file.
+
+ Args:
+ file_name: log file name to write log to.
+ ssh: paramiko client object.
+ """
+ iperf_log_dir = os.path.join(self.root_output_path, 'iperf')
+ os.makedirs(iperf_log_dir, exist_ok=True)
+ iperf_log_file_path = os.path.join(iperf_log_dir, file_name)
+ with open(iperf_log_file_path, 'w') as f:
+ out, err = self.iperf_out_err[ssh]
+ out_content = ''.join(out.readlines())
+ err_content = ''.join(err.readlines())
+ f.write(out_content)
+ f.write('\nErrors:\n')
+ f.write(err_content)
+
+ def turn_on_mobile_data(self):
+ self.dut.adb.shell(self.ADB_CMD_ENABLE_MOBILE_DATA)
class PowerTelTraffic_Preset_Test(PowerTelTrafficPresetTest):
-
def test_preset_LTE_traffic(self):
self.power_tel_traffic_test()
+
+ def test_preset_nsa_traffic_fr1(self):
+ self.power_tel_traffic_test()
+
+ def test_preset_sa_traffic_fr1(self):
+ self.power_tel_traffic_test()
+
+
+class PowerTelTrafficFr2_Preset_Test(PowerTelTrafficPresetTest):
+ def test_preset_nsa_traffic_fr2(self):
+ self.power_tel_traffic_test()
diff --git a/acts_tests/tests/google/power/wifi/PowerWiFiHotspotTest.py b/acts_tests/tests/google/power/wifi/PowerWiFiHotspotTest.py
index 7e7c3b8..e0013b1 100644
--- a/acts_tests/tests/google/power/wifi/PowerWiFiHotspotTest.py
+++ b/acts_tests/tests/google/power/wifi/PowerWiFiHotspotTest.py
@@ -23,6 +23,7 @@
from acts_contrib.test_utils.wifi import wifi_power_test_utils as wputils
from acts_contrib.test_utils.power.IperfHelper import IperfHelper
+WAIT_TIME_BEFORE_CONNECT = 10
class PowerWiFiHotspotTest(PWBT.PowerWiFiBaseTest):
""" WiFi Tethering HotSpot Power test.
@@ -60,6 +61,7 @@
Configures the Hotspot SSID
"""
super().setup_class()
+ self.set_attenuation([0, 0, 0, 0])
# If an SSID and password are indicated in the configuration parameters,
# use those. If not, use default parameters and warn the user.
@@ -101,6 +103,15 @@
super().setup_test()
wutils.reset_wifi(self.android_devices[1])
+ def teardown_test(self):
+ # Tearing down tethering on dut
+ if self.dut.droid.isSdkAtLeastS():
+ hotspot_cmd = "cmd wifi stop-softap " + str(self.network[wutils.WifiEnums.SSID_KEY]) + \
+ " wpa2 " + str(self.network[wutils.WifiEnums.PWD_KEY]) + " -b " + \
+ str(list(self.test_configs.band)[0])
+ self.dut.adb.shell(hotspot_cmd)
+ wutils.reset_wifi(self.android_devices[1])
+
def setup_hotspot(self, connect_client=False):
"""Configure Hotspot and connects client device.
@@ -134,12 +145,21 @@
self.main_network[self.test_configs.wifi_sharing])
# Setup tethering on dut
- wutils.start_wifi_tethering(
- self.dut, self.network[wutils.WifiEnums.SSID_KEY],
- self.network[wutils.WifiEnums.PWD_KEY], wifi_band_id)
+ if self.dut.droid.isSdkAtLeastS():
+ # Setup tethering on dut with adb command.
+ hotspot_cmd = "cmd wifi start-softap " + str(self.network[wutils.WifiEnums.SSID_KEY]) + \
+ " wpa2 " + str(self.network[wutils.WifiEnums.PWD_KEY]) + " -b " + \
+ str(list(self.test_configs.band)[0])
+ self.log.info(str(hotspot_cmd))
+ self.dut.adb.shell(hotspot_cmd)
+ else:
+ wutils.start_wifi_tethering(
+ self.dut, self.network[wutils.WifiEnums.SSID_KEY],
+ self.network[wutils.WifiEnums.PWD_KEY], wifi_band_id)
# Connect client device to Hotspot
if connect_client:
+ time.sleep(WAIT_TIME_BEFORE_CONNECT)
wutils.wifi_connect(
self.android_devices[1],
self.network,
@@ -168,7 +188,14 @@
self.client_iperf_helper.process_iperf_results(
self.dut, self.log, self.iperf_servers, self.test_name)
- self.pass_fail_check(self.avg_current)
+ if hasattr(self, 'bitses'):
+ """
+ If measurement is taken through BITS, metric value is avg_power,
+ else metric value is avg_current.
+ """
+ self.pass_fail_check(self.power_result.metric_value)
+ else:
+ self.pass_fail_check(self.avg_current)
def power_idle_tethering_test(self):
""" Start power test when Hotspot is idle
diff --git a/acts_tests/tests/google/power/wifi/PowerWiFiscanTest.py b/acts_tests/tests/google/power/wifi/PowerWiFiscanTest.py
index 72f733f..da1c67d 100644
--- a/acts_tests/tests/google/power/wifi/PowerWiFiscanTest.py
+++ b/acts_tests/tests/google/power/wifi/PowerWiFiscanTest.py
@@ -18,10 +18,20 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.power import PowerWiFiBaseTest as PWBT
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts_contrib.test_utils.wifi.wifi_power_test_utils import CHRE_WIFI_SCAN_TYPE
+from acts_contrib.test_utils.wifi.wifi_power_test_utils import CHRE_WIFI_RADIO_CHAIN
+from acts_contrib.test_utils.wifi.wifi_power_test_utils import CHRE_WIFI_CHANNEL_SET
UNLOCK_SCREEN = 'input keyevent 82'
LOCATION_ON = 'settings put secure location_mode 3'
-
+ENABLE_WIFI_SCANNING = 'cmd wifi enable-scanning enabled'
+DISABLE_WIFI_SCANNING = 'cmd wifi enable-scanning disabled'
+CHRE_POWER_TEST_CLIENT = 'chre_power_test_client'
+UNLOAD_ALL_CHRE_PRODUCTION_APP = CHRE_POWER_TEST_CLIENT + ' unloadall'
+LOAD_CHRE_TEST_NANOAPP = CHRE_POWER_TEST_CLIENT + ' load'
+DISABLE_CHRE_WIFI_SCAN = CHRE_POWER_TEST_CLIENT + ' wifi disable'
+CHRE_SCAN_INTERVAL = 5
+NS = 1000000000
class PowerWiFiscanTest(PWBT.PowerWiFiBaseTest):
def setup_class(self):
@@ -71,6 +81,25 @@
atten_setting = self.test_configs.wifi_band + '_roaming'
self.set_attenuation(self.atten_level[atten_setting])
+ def chre_scan_setup(self):
+ self.dut.adb.shell("cmd wifi force-country-code enabled US")
+ time.sleep(1)
+ country_code = self.dut.adb.shell("cmd wifi get-country-code")
+ if "US" in country_code:
+ self.log.info("Country-Code is set to US")
+ else:
+ self.log.warning("Country Code is : " + str(country_code))
+ self.dut.adb.shell(DISABLE_WIFI_SCANNING)
+ self.dut.adb.shell(UNLOAD_ALL_CHRE_PRODUCTION_APP)
+ self.dut.adb.shell(LOAD_CHRE_TEST_NANOAPP)
+ chre_wifi_scan_trigger_cmd = CHRE_POWER_TEST_CLIENT + ' wifi enable ' + \
+ str(CHRE_SCAN_INTERVAL*NS) + \
+ " " + CHRE_WIFI_SCAN_TYPE[self.test_configs.wifi_scan_type] + " " + \
+ CHRE_WIFI_RADIO_CHAIN[self.test_configs.wifi_radio_chain] + " " + \
+ CHRE_WIFI_CHANNEL_SET[self.test_configs.wifi_channel_set]
+ self.dut.log.info(chre_wifi_scan_trigger_cmd)
+ self.dut.adb.shell(chre_wifi_scan_trigger_cmd)
+
def wifi_scan_test_func(self):
attrs = [
@@ -94,6 +123,22 @@
self.scan_setup()
self.measure_power_and_validate()
+ def chre_wifi_scan_test_func(self):
+ attrs = [
+ 'screen_status', 'wifi_scan_type', 'wifi_radio_chain', 'wifi_channel_set'
+ ]
+ indices = [2, 6, 7, 8]
+ self.decode_test_configs(attrs, indices)
+ wutils.wifi_toggle_state(self.dut, True)
+ if self.test_configs.screen_status == 'OFF':
+ self.dut.droid.goToSleepNow()
+ self.dut.log.info('Screen is OFF')
+ time.sleep(5)
+ self.chre_scan_setup()
+ self.measure_power_and_validate()
+ self.dut.adb.shell(DISABLE_CHRE_WIFI_SCAN)
+ self.dut.adb.shell(ENABLE_WIFI_SCANNING)
+
# Test cases
# Power.apk triggered singleshot scans
@test_tracker_info(uuid='e5539b01-e208-43c6-bebf-6f1e73d8d8cb')
@@ -157,3 +202,52 @@
"""
self.wifi_scan_test_func()
+
+ def test_screen_OFF_CHRE_wifi_scan_activePassiveDfs_highAccuracy_all(self):
+ """
+ Trigger CHRE based scan for the following parameters :
+ wifi_scan_type : activePassiveDfs
+ wifi_radio_chain : highAccuracy
+ wifi_channel_set : all
+ """
+ self.chre_wifi_scan_test_func()
+
+
+ def test_screen_OFF_CHRE_wifi_scan_activePassiveDfs_lowLatency_all(self):
+ """
+ Trigger CHRE based scan for the following parameters :
+ wifi_scan_type : activePassiveDfs
+ wifi_radio_chain : lowLatency
+ wifi_channel_set : all
+ """
+ self.chre_wifi_scan_test_func()
+
+
+ def test_screen_OFF_CHRE_wifi_scan_noPreference_lowPower_all(self):
+ """
+ Trigger CHRE based scan for the following parameters :
+ wifi_scan_type : noPreference
+ wifi_radio_chain : lowPower
+ wifi_channel_set : all
+ """
+ self.chre_wifi_scan_test_func()
+
+
+ def test_screen_OFF_CHRE_wifi_scan_passive_lowLatency_all(self):
+ """
+ Trigger CHRE based scan for the following parameters :
+ wifi_scan_type : passive
+ wifi_radio_chain : lowLatency
+ wifi_channel_set : all
+ """
+ self.chre_wifi_scan_test_func()
+
+
+ def test_screen_OFF_CHRE_wifi_scan_passive_highAccuracy_all(self):
+ """
+ Trigger CHRE based scan for the following parameters :
+ wifi_scan_type : passive
+ wifi_radio_chain : highAccuracy
+ wifi_channel_set : all
+ """
+ self.chre_wifi_scan_test_func()
\ No newline at end of file
diff --git a/acts_tests/tests/google/wifi/WifiBridgedApTest.py b/acts_tests/tests/google/wifi/WifiBridgedApTest.py
index 01cb744..d98a7cb 100644
--- a/acts_tests/tests/google/wifi/WifiBridgedApTest.py
+++ b/acts_tests/tests/google/wifi/WifiBridgedApTest.py
@@ -57,7 +57,10 @@
self.client1 = self.android_devices[1]
self.client2 = self.android_devices[2]
else:
- raise signals.TestFailure("WifiBridgedApTest requires 3 DUTs")
+ raise signals.TestAbortClass("WifiBridgedApTest requires 3 DUTs")
+
+ if not self.dut.droid.wifiIsBridgedApConcurrencySupported():
+ raise signals.TestAbortClass("Legacy phone is not supported")
req_params = ["dbs_supported_models"]
opt_param = []
@@ -1329,4 +1332,4 @@
self.dut, [WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G,
WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G], False)
# Restore config
- wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
+ wutils.save_wifi_soft_ap_config(self.dut, original_softap_config)
\ No newline at end of file
diff --git a/acts_tests/tests/google/wifi/WifiPingTest.py b/acts_tests/tests/google/wifi/WifiPingTest.py
index 096a935..ca1ccd7 100644
--- a/acts_tests/tests/google/wifi/WifiPingTest.py
+++ b/acts_tests/tests/google/wifi/WifiPingTest.py
@@ -504,26 +504,56 @@
"""
# Configure AP
self.setup_ap(testcase_params)
- # Set attenuator to 0 dB
+ # Set attenuator to starting attenuation
+ band = wputils.CHANNEL_TO_BAND_MAP[testcase_params['channel']]
for attenuator in self.attenuators:
- attenuator.set_atten(testcase_params['atten_range'][0],
- strict=False,
- retry=True)
+ attenuator.set_atten(
+ self.testclass_params['range_atten_start'].get(band, 0),
+ strict=False,
+ retry=True)
# Reset, configure, and connect DUT
self.setup_dut(testcase_params)
def get_range_start_atten(self, testcase_params):
"""Gets the starting attenuation for this ping test.
- This function is used to get the starting attenuation for ping range
- tests. This implementation returns the default starting attenuation,
- however, defining this function enables a more involved configuration
- for over-the-air test classes.
+ The function gets the starting attenuation by checking whether a test
+ at the same configuration has executed. If so it sets the starting
+ point a configurable number of dBs below the reference test.
Args:
- testcase_params: dict containing all test params
+ testcase_params: dict containing all test parameters
+ Returns:
+ start_atten: starting attenuation for current test
"""
- return self.testclass_params['range_atten_start']
+ band = wputils.CHANNEL_TO_BAND_MAP[testcase_params['channel']]
+ # If the test is being retried, start from the beginning
+ if self.retry_flag:
+ self.log.info('Retry flag set. Setting attenuation to minimum.')
+ return self.testclass_params['range_atten_start'].get(band, 0)
+ # Get the current and reference test config. The reference test is the
+ # one performed at the current MCS+1
+ ref_test_params = wputils.extract_sub_dict(
+ testcase_params, testcase_params['reference_params'])
+ # Check if reference test has been run and set attenuation accordingly
+ previous_params = [
+ wputils.extract_sub_dict(result['testcase_params'],
+ testcase_params['reference_params'])
+ for result in self.testclass_results
+ ]
+ try:
+ ref_index = previous_params[::-1].index(ref_test_params)
+ ref_index = len(previous_params) - 1 - ref_index
+ start_atten = self.testclass_results[ref_index][
+ 'atten_at_range'] - (
+ self.testclass_params['adjacent_range_test_gap'])
+ except ValueError:
+ start_atten = self.testclass_params['range_atten_start'].get(
+ band, 0)
+ self.log.info(
+ 'Reference test not found. Starting from {} dB'.format(
+ start_atten))
+ return start_atten
def compile_test_params(self, testcase_params):
# Check if test should be skipped.
@@ -534,6 +564,7 @@
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
testcase_params['test_network'] = self.main_network[band]
+ testcase_params['band'] = band
if testcase_params['chain_mask'] in ['0', '1']:
testcase_params['attenuated_chain'] = 'DUT-Chain-{}'.format(
1 if testcase_params['chain_mask'] == '0' else 0)
@@ -595,7 +626,7 @@
self.pass_fail_check(ping_result)
def generate_test_cases(self, ap_power, channels, modes, chain_mask,
- test_types):
+ test_types, **kwargs):
"""Function that auto-generates test cases for a test class."""
test_cases = []
allowed_configs = {
@@ -620,7 +651,8 @@
channel=channel,
mode=mode,
bandwidth=bandwidth,
- chain_mask=chain)
+ chain_mask=chain,
+ **kwargs)
setattr(self, testcase_name,
partial(self._test_ping, testcase_params))
test_cases.append(testcase_name)
@@ -628,46 +660,50 @@
class WifiPing_TwoChain_Test(WifiPingTest):
+
def __init__(self, controllers):
super().__init__(controllers)
- self.tests = self.generate_test_cases(ap_power='standard',
- channels=[
- 1, 6, 11, 36, 40, 44, 48,
- 149, 153, 157, 161, '6g37',
- '6g117', '6g213'
- ],
- modes=['bw20', 'bw40', 'bw80'],
- test_types=[
- 'test_ping_range',
- 'test_fast_ping_rtt',
- 'test_slow_ping_rtt'
- ],
- chain_mask=['2x2'])
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
+ modes=['bw20', 'bw80', 'bw160'],
+ test_types=[
+ 'test_ping_range', 'test_fast_ping_rtt', 'test_slow_ping_rtt'
+ ],
+ chain_mask=['2x2'],
+ reference_params=['band', 'chain_mask'])
class WifiPing_PerChainRange_Test(WifiPingTest):
+
def __init__(self, controllers):
super().__init__(controllers)
- self.tests = self.generate_test_cases(ap_power='standard',
- chain_mask=['0', '1', '2x2'],
- channels=[
- 1, 6, 11, 36, 40, 44, 48,
- 149, 153, 157, 161, '6g37',
- '6g117', '6g213'
- ],
- modes=['bw20', 'bw40', 'bw80'],
- test_types=['test_ping_range'])
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ chain_mask=['0', '1', '2x2'],
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
+ modes=['bw20', 'bw80', 'bw160'],
+ test_types=['test_ping_range'],
+ reference_params=['band', 'chain_mask'])
class WifiPing_LowPowerAP_Test(WifiPingTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
ap_power='low_power',
chain_mask=['0', '1', '2x2'],
channels=[1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
- modes=['bw20', 'bw40', 'bw80'],
- test_types=['test_ping_range'])
+ modes=['bw20', 'bw80'],
+ test_types=['test_ping_range'],
+ reference_params=['band', 'chain_mask'])
# Over-the air version of ping tests
@@ -678,6 +714,7 @@
setting turntable orientation and other chamber parameters to study
performance in varying channel conditions
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
self.testcase_metric_logger = (
@@ -788,45 +825,8 @@
# Continue setting up ping test
WifiPingTest.setup_ping_test(self, testcase_params)
- def get_range_start_atten(self, testcase_params):
- """Gets the starting attenuation for this ping test.
-
- The function gets the starting attenuation by checking whether a test
- at the same configuration has executed. If so it sets the starting
- point a configurable number of dBs below the reference test.
-
- Returns:
- start_atten: starting attenuation for current test
- """
- # If the test is being retried, start from the beginning
- if self.retry_flag:
- self.log.info('Retry flag set. Setting attenuation to minimum.')
- return self.testclass_params['range_atten_start']
- # Get the current and reference test config. The reference test is the
- # one performed at the current MCS+1
- ref_test_params = wputils.extract_sub_dict(
- testcase_params, ['channel', 'mode', 'chain_mask'])
- # Check if reference test has been run and set attenuation accordingly
- previous_params = [
- wputils.extract_sub_dict(result['testcase_params'],
- ['channel', 'mode', 'chain_mask'])
- for result in self.testclass_results
- ]
- try:
- ref_index = previous_params[::-1].index(ref_test_params)
- ref_index = len(previous_params) - 1 - ref_index
- start_atten = self.testclass_results[ref_index][
- 'atten_at_range'] - (
- self.testclass_params['adjacent_range_test_gap'])
- except ValueError:
- self.log.info(
- 'Reference test not found. Starting from {} dB'.format(
- self.testclass_params['range_atten_start']))
- start_atten = self.testclass_params['range_atten_start']
- return start_atten
-
def generate_test_cases(self, ap_power, channels, modes, chain_masks,
- chamber_mode, positions):
+ chamber_mode, positions, **kwargs):
test_cases = []
allowed_configs = {
20: [
@@ -853,7 +853,8 @@
chain_mask=chain_mask,
chamber_mode=chamber_mode,
total_positions=len(positions),
- position=position)
+ position=position,
+ **kwargs)
setattr(self, testcase_name,
partial(self._test_ping, testcase_params))
test_cases.append(testcase_name)
@@ -861,6 +862,7 @@
class WifiOtaPing_TenDegree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
@@ -869,49 +871,57 @@
modes=['bw20'],
chain_masks=['2x2'],
chamber_mode='orientation',
- positions=list(range(0, 360, 10)))
+ positions=list(range(0, 360, 10)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_45Degree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
- self.tests = self.generate_test_cases(ap_power='standard',
- channels=[
- 1, 6, 11, 36, 40, 44, 48,
- 149, 153, 157, 161, '6g37',
- '6g117', '6g213'
- ],
- modes=['bw20'],
- chain_masks=['2x2'],
- chamber_mode='orientation',
- positions=list(range(0, 360,
- 45)))
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
+ modes=['bw20'],
+ chain_masks=['2x2'],
+ chamber_mode='orientation',
+ positions=list(range(0, 360, 45)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_SteppedStirrers_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
- self.tests = self.generate_test_cases(ap_power='standard',
- channels=[6, 36, 149],
- modes=['bw20'],
- chain_masks=['2x2'],
- chamber_mode='stepped stirrers',
- positions=list(range(100)))
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[6, 36, 149],
+ modes=['bw20'],
+ chain_masks=['2x2'],
+ chamber_mode='stepped stirrers',
+ positions=list(range(100)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_LowPowerAP_TenDegree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
- self.tests = self.generate_test_cases(ap_power='low_power',
- channels=[6, 36, 149],
- modes=['bw20'],
- chain_masks=['2x2'],
- chamber_mode='orientation',
- positions=list(range(0, 360,
- 10)))
+ self.tests = self.generate_test_cases(
+ ap_power='low_power',
+ channels=[6, 36, 149],
+ modes=['bw20'],
+ chain_masks=['2x2'],
+ chamber_mode='orientation',
+ positions=list(range(0, 360, 10)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_LowPowerAP_45Degree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
@@ -920,33 +930,40 @@
modes=['bw20'],
chain_masks=['2x2'],
chamber_mode='orientation',
- positions=list(range(0, 360, 45)))
+ positions=list(range(0, 360, 45)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_LowPowerAP_SteppedStirrers_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
- self.tests = self.generate_test_cases(ap_power='low_power',
- channels=[6, 36, 149],
- modes=['bw20'],
- chain_masks=['2x2'],
- chamber_mode='stepped stirrers',
- positions=list(range(100)))
+ self.tests = self.generate_test_cases(
+ ap_power='low_power',
+ channels=[6, 36, 149],
+ modes=['bw20'],
+ chain_masks=['2x2'],
+ chamber_mode='stepped stirrers',
+ positions=list(range(100)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_LowPowerAP_PerChain_TenDegree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
- self.tests = self.generate_test_cases(ap_power='low_power',
- channels=[6, 36, 149],
- modes=['bw20'],
- chain_masks=[0, 1, '2x2'],
- chamber_mode='orientation',
- positions=list(range(0, 360,
- 10)))
+ self.tests = self.generate_test_cases(
+ ap_power='low_power',
+ channels=[6, 36, 149],
+ modes=['bw20'],
+ chain_masks=[0, 1, '2x2'],
+ chamber_mode='orientation',
+ positions=list(range(0, 360, 10)),
+ reference_params=['channel', 'mode', 'chain_mask'])
class WifiOtaPing_PerChain_TenDegree_Test(WifiOtaPingTest):
+
def __init__(self, controllers):
WifiOtaPingTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
@@ -955,4 +972,5 @@
modes=['bw20'],
chain_masks=[0, 1, '2x2'],
chamber_mode='orientation',
- positions=list(range(0, 360, 10)))
+ positions=list(range(0, 360, 10)),
+ reference_params=['channel', 'mode', 'chain_mask'])
diff --git a/acts_tests/tests/google/wifi/WifiRssiTest.py b/acts_tests/tests/google/wifi/WifiRssiTest.py
index 06eed43..452591f 100644
--- a/acts_tests/tests/google/wifi/WifiRssiTest.py
+++ b/acts_tests/tests/google/wifi/WifiRssiTest.py
@@ -53,6 +53,7 @@
configurable attenuation waveforms.For an example config file to run this
test class see example_connectivity_performance_ap_sta.json.
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
self.testcase_metric_logger = (
@@ -494,12 +495,12 @@
thread_future = wputils.get_ping_stats_nb(
self.remote_server, self.dut_ip,
testcase_params['traffic_timeout'], 0.5, 64)
+ llstats_obj.update_stats()
for atten in testcase_params['rssi_atten_range']:
# Set Attenuation
self.log.info('Setting attenuation to {} dB'.format(atten))
for attenuator in self.attenuators:
attenuator.set_atten(atten)
- llstats_obj.update_stats()
current_rssi = collections.OrderedDict()
current_rssi = wputils.get_connected_rssi(
self.dut, testcase_params['connected_measurements'],
@@ -633,9 +634,13 @@
testclass_params['rssi_vs_atten_connected_measurements'],
scan_measurements=self.
testclass_params['rssi_vs_atten_scan_measurements'],
- first_measurement_delay=MED_SLEEP,
- rssi_under_test=self.testclass_params['rssi_vs_atten_metrics'],
+ first_measurement_delay=SHORT_SLEEP,
absolute_accuracy=1)
+ rssi_under_test = self.testclass_params['rssi_vs_atten_metrics']
+ if self.testclass_params[
+ 'rssi_vs_atten_scan_measurements'] == 0 and 'scan_rssi' in rssi_under_test:
+ rssi_under_test.remove('scan_rssi')
+ testcase_params['rssi_under_test'] = rssi_under_test
testcase_params['band'] = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
@@ -677,7 +682,7 @@
self.testclass_params['rssi_stability_duration'] /
self.testclass_params['polling_frequency']),
scan_measurements=0,
- first_measurement_delay=MED_SLEEP,
+ first_measurement_delay=SHORT_SLEEP,
rssi_atten_range=self.testclass_params['rssi_stability_atten'])
testcase_params['band'] = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
@@ -846,6 +851,7 @@
class WifiRssi_2GHz_ActiveTraffic_Test(WifiRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -854,6 +860,7 @@
class WifiRssi_5GHz_ActiveTraffic_Test(WifiRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -863,6 +870,7 @@
class WifiRssi_AllChannels_ActiveTraffic_Test(WifiRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -873,6 +881,7 @@
class WifiRssi_SampleChannels_NoTraffic_Test(WifiRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -881,6 +890,7 @@
class WifiRssiTrackingTest(WifiRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(['test_rssi_tracking'],
@@ -897,6 +907,7 @@
It allows setting orientation and other chamber parameters to study
performance in varying channel conditions
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
self.testcase_metric_logger = (
@@ -1027,7 +1038,7 @@
testcase_params.update(connected_measurements=int(
rssi_test_duration / self.testclass_params['polling_frequency']),
scan_measurements=0,
- first_measurement_delay=MED_SLEEP,
+ first_measurement_delay=SHORT_SLEEP,
rssi_atten_range=rssi_ota_test_attenuation)
testcase_params['band'] = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
@@ -1100,6 +1111,7 @@
class WifiOtaRssi_Accuracy_Test(WifiOtaRssiTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(['test_rssi_vs_atten'],
@@ -1110,6 +1122,7 @@
class WifiOtaRssi_StirrerVariation_Test(WifiOtaRssiTest):
+
def __init__(self, controllers):
WifiRssiTest.__init__(self, controllers)
self.tests = self.generate_test_cases(['test_rssi_variation'],
@@ -1119,6 +1132,7 @@
class WifiOtaRssi_TenDegree_Test(WifiOtaRssiTest):
+
def __init__(self, controllers):
WifiRssiTest.__init__(self, controllers)
self.tests = self.generate_test_cases(['test_rssi_over_orientation'],
diff --git a/acts_tests/tests/google/wifi/WifiRvrTest.py b/acts_tests/tests/google/wifi/WifiRvrTest.py
index ffa52d5..4a64552 100644
--- a/acts_tests/tests/google/wifi/WifiRvrTest.py
+++ b/acts_tests/tests/google/wifi/WifiRvrTest.py
@@ -137,14 +137,23 @@
primary_y_label='Throughput (Mbps)')
plots[plot_id].add_line(result['total_attenuation'],
result['throughput_receive'],
- result['test_name'],
+ result['test_name'].strip('test_rvr_'),
hover_text=result['hover_text'],
marker='circle')
plots[plot_id].add_line(result['total_attenuation'],
- result['avg_phy_rate'],
- result['test_name'] + ' (PHY)',
+ result['rx_phy_rate'],
+ result['test_name'].strip('test_rvr_') +
+ ' (Rx PHY)',
hover_text=result['hover_text'],
- marker='circle')
+ style='dashed',
+ marker='inverted_triangle')
+ plots[plot_id].add_line(result['total_attenuation'],
+ result['tx_phy_rate'],
+ result['test_name'].strip('test_rvr_') +
+ ' (Tx PHY)',
+ hover_text=result['hover_text'],
+ style='dashed',
+ marker='triangle')
figure_list = []
for plot_id, plot in plots.items():
@@ -311,39 +320,36 @@
) for rssi in rvr_result['rssi']
]
}
- if 'DL' in self.current_test_name:
- rvr_result['avg_phy_rate'] = [
- curr_llstats['summary'].get('mean_rx_phy_rate', 0)
- for curr_llstats in rvr_result['llstats']
- ]
- else:
- rvr_result['avg_phy_rate'] = [
- curr_llstats['summary'].get('mean_tx_phy_rate', 0)
- for curr_llstats in rvr_result['llstats']
- ]
+
figure.add_line(rvr_result['total_attenuation'],
rvr_result['throughput_receive'],
'Measured Throughput',
hover_text=rvr_result['hover_text'],
- color='red',
+ color='black',
marker='circle')
- rvr_result['avg_phy_rate'].extend(
- [0] * (len(rvr_result['total_attenuation']) -
- len(rvr_result['avg_phy_rate'])))
- figure.add_line(rvr_result['total_attenuation'],
- rvr_result['avg_phy_rate'],
- 'Average PHY Rate',
- hover_text=rvr_result['hover_text'],
- color='red',
- style='dashed',
- marker='square')
+ figure.add_line(
+ rvr_result['total_attenuation'][0:len(rvr_result['rx_phy_rate'])],
+ rvr_result['rx_phy_rate'],
+ 'Rx PHY Rate',
+ hover_text=rvr_result['hover_text'],
+ color='blue',
+ style='dashed',
+ marker='inverted_triangle')
+ figure.add_line(
+ rvr_result['total_attenuation'][0:len(rvr_result['rx_phy_rate'])],
+ rvr_result['tx_phy_rate'],
+ 'Tx PHY Rate',
+ hover_text=rvr_result['hover_text'],
+ color='red',
+ style='dashed',
+ marker='triangle')
output_file_path = os.path.join(
self.log_path, '{}.html'.format(self.current_test_name))
figure.generate_figure(output_file_path)
def compute_test_metrics(self, rvr_result):
- #Set test metrics
+ # Set test metrics
rvr_result['metrics'] = {}
rvr_result['metrics']['peak_tput'] = max(
rvr_result['throughput_receive'])
@@ -362,7 +368,7 @@
for idx in range(len(tput_below_limit)):
if all(tput_below_limit[idx:]):
if idx == 0:
- #Throughput was never above limit
+ # Throughput was never above limit
rvr_result['metrics']['high_tput_range'] = -1
else:
rvr_result['metrics']['high_tput_range'] = rvr_result[
@@ -411,6 +417,8 @@
self.testclass_params.get('monitor_llstats', 1))
zero_counter = 0
throughput = []
+ rx_phy_rate = []
+ tx_phy_rate = []
llstats = []
rssi = []
for atten in testcase_params['atten_range']:
@@ -479,6 +487,10 @@
llstats_obj.update_stats()
curr_llstats = llstats_obj.llstats_incremental.copy()
llstats.append(curr_llstats)
+ rx_phy_rate.append(curr_llstats['summary'].get(
+ 'mean_rx_phy_rate', 0))
+ tx_phy_rate.append(curr_llstats['summary'].get(
+ 'mean_tx_phy_rate', 0))
self.log.info(
('Throughput at {0:.2f} dB is {1:.2f} Mbps. '
'RSSI = {2:.2f} [{3:.2f}, {4:.2f}].').format(
@@ -492,9 +504,11 @@
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)))
+ zero_padding = len(
+ testcase_params['atten_range']) - len(throughput)
+ throughput.extend([0] * zero_padding)
+ rx_phy_rate.extend([0] * zero_padding)
+ tx_phy_rate.extend([0] * zero_padding)
break
for attenuator in self.attenuators:
attenuator.set_atten(0, strict=False, retry=True)
@@ -512,6 +526,8 @@
]
rvr_result['rssi'] = rssi
rvr_result['throughput_receive'] = throughput
+ rvr_result['rx_phy_rate'] = rx_phy_rate
+ rvr_result['tx_phy_rate'] = tx_phy_rate
rvr_result['llstats'] = llstats
return rvr_result
@@ -556,8 +572,9 @@
self.sta_dut.droid.wakeLockAcquireDim()
else:
self.sta_dut.go_to_sleep()
- if wputils.validate_network(self.sta_dut,
- testcase_params['test_network']['SSID']):
+ if (wputils.validate_network(self.sta_dut,
+ testcase_params['test_network']['SSID'])
+ and not self.testclass_params.get('force_reconnect', 0)):
self.log.info('Already connected to desired network')
else:
wutils.wifi_toggle_state(self.sta_dut, False)
@@ -733,6 +750,7 @@
class WifiRvr_TCP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -746,6 +764,7 @@
class WifiRvr_VHT_TCP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -756,6 +775,7 @@
class WifiRvr_HE_TCP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -769,6 +789,7 @@
class WifiRvr_SampleUDP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -779,6 +800,7 @@
class WifiRvr_VHT_SampleUDP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -789,6 +811,7 @@
class WifiRvr_HE_SampleUDP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -799,6 +822,7 @@
class WifiRvr_SampleDFS_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -809,6 +833,7 @@
class WifiRvr_SingleChain_TCP_Test(WifiRvrTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -867,6 +892,7 @@
setting turntable orientation and other chamber parameters to study
performance in varying channel conditions
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
self.testcase_metric_logger = (
@@ -902,7 +928,12 @@
]).items())
if test_id not in plots:
# Initialize test id data when not present
- compiled_data[test_id] = {'throughput': [], 'metrics': {}}
+ compiled_data[test_id] = {
+ 'throughput': [],
+ 'rx_phy_rate': [],
+ 'tx_phy_rate': [],
+ 'metrics': {}
+ }
compiled_data[test_id]['metrics'] = {
key: []
for key in result['metrics'].keys()
@@ -927,6 +958,8 @@
# Compile test id data and metrics
compiled_data[test_id]['throughput'].append(
result['throughput_receive'])
+ compiled_data[test_id]['rx_phy_rate'].append(result['rx_phy_rate'])
+ compiled_data[test_id]['tx_phy_rate'].append(result['tx_phy_rate'])
compiled_data[test_id]['total_attenuation'] = result[
'total_attenuation']
for metric_key, metric_value in result['metrics'].items():
@@ -935,18 +968,27 @@
# Add test id to plots
plots[test_id].add_line(result['total_attenuation'],
result['throughput_receive'],
- result['test_name'],
+ result['test_name'].strip('test_rvr_'),
hover_text=result['hover_text'],
width=1,
style='dashed',
marker='circle')
- plots[test_id_phy].add_line(result['total_attenuation'],
- result['avg_phy_rate'],
- result['test_name'] + ' PHY',
- hover_text=result['hover_text'],
- width=1,
- style='dashed',
- marker='circle')
+ plots[test_id_phy].add_line(
+ result['total_attenuation'],
+ result['rx_phy_rate'],
+ result['test_name'].strip('test_rvr_') + ' Rx PHY Rate',
+ hover_text=result['hover_text'],
+ width=1,
+ style='dashed',
+ marker='inverted_triangle')
+ plots[test_id_phy].add_line(
+ result['total_attenuation'],
+ result['tx_phy_rate'],
+ result['test_name'].strip('test_rvr_') + ' Tx PHY Rate',
+ hover_text=result['hover_text'],
+ width=1,
+ style='dashed',
+ marker='triangle')
# Compute average RvRs and compute metrics over orientations
for test_id, test_data in compiled_data.items():
@@ -966,6 +1008,10 @@
metric_key, metric_value)
test_data['avg_rvr'] = numpy.mean(test_data['throughput'], 0)
test_data['median_rvr'] = numpy.median(test_data['throughput'], 0)
+ test_data['avg_rx_phy_rate'] = numpy.mean(test_data['rx_phy_rate'],
+ 0)
+ test_data['avg_tx_phy_rate'] = numpy.mean(test_data['tx_phy_rate'],
+ 0)
plots[test_id].add_line(test_data['total_attenuation'],
test_data['avg_rvr'],
legend='Average Throughput',
@@ -974,6 +1020,15 @@
test_data['median_rvr'],
legend='Median Throughput',
marker='square')
+ test_id_phy = test_id + tuple('PHY')
+ plots[test_id_phy].add_line(test_data['total_attenuation'],
+ test_data['avg_rx_phy_rate'],
+ legend='Average Rx Rate',
+ marker='inverted_triangle')
+ plots[test_id_phy].add_line(test_data['total_attenuation'],
+ test_data['avg_tx_phy_rate'],
+ legend='Average Tx Rate',
+ marker='triangle')
figure_list = []
for plot_id, plot in plots.items():
@@ -1019,6 +1074,7 @@
class WifiOtaRvr_StandardOrientation_Test(WifiOtaRvrTest):
+
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
@@ -1028,6 +1084,7 @@
class WifiOtaRvr_SampleChannel_Test(WifiOtaRvrTest):
+
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases([6], ['bw20'],
@@ -1042,6 +1099,7 @@
class WifiOtaRvr_SingleOrientation_Test(WifiOtaRvrTest):
+
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
@@ -1050,6 +1108,7 @@
class WifiOtaRvr_SingleChain_Test(WifiOtaRvrTest):
+
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases([6], ['bw20'],
diff --git a/acts_tests/tests/google/wifi/WifiRvrTwTest.py b/acts_tests/tests/google/wifi/WifiRvrTwTest.py
index e732b83..6e2babe 100644
--- a/acts_tests/tests/google/wifi/WifiRvrTwTest.py
+++ b/acts_tests/tests/google/wifi/WifiRvrTwTest.py
@@ -25,6 +25,8 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
from acts.controllers import iperf_server as ipf
+from acts.controllers import attenuator
+from acts.controllers.sl4a_lib import rpc_client
import json
import logging
@@ -35,446 +37,688 @@
import serial
import sys
+import urllib.request
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils_RSSI as wperfutils
WifiEnums = wutils.WifiEnums
-class WifiRvrTWTest(WifiBaseTest):
- """ Tests for wifi RVR performance
+class WifiRvrTwTest(WifiBaseTest):
+ """ Tests for wifi RVR performance.
Test Bed Requirement:
* One Android device
* Wi-Fi networks visible to the device
+ """
+ TEST_TIMEOUT = 10
+ IPERF_SETUP_TIME = 5
+ TURN_TABLE_SETUP_TIME = 5
+
+ def __init__(self, controllers):
+ WifiBaseTest.__init__(self, controllers)
+
+ def setup_class(self):
+ self.dut = self.android_devices[0]
+
+ req_params = ["rvr_networks", "rvr_test_params", "attenuators"]
+ opt_params = ["angle_params", "usb_port"]
+ self.unpack_userparams(
+ req_param_names=req_params, opt_param_names=opt_params)
+ asserts.assert_true(
+ len(self.rvr_networks) > 0, "Need at least one network.")
+
+ if "rvr_test_params" in self.user_params:
+ self.iperf_server = self.iperf_servers[0]
+ self.maxdb = self.rvr_test_params["rvr_atten_maxdb"]
+ self.mindb = self.rvr_test_params["rvr_atten_mindb"]
+ self.stepdb = self.rvr_test_params["rvr_atten_step"]
+ self.country_code = self.rvr_test_params["country_code"]
+ if "angle_params" in self.user_params:
+ self.angle_list = self.angle_params
+ if "usb_port" in self.user_params:
+ self.turntable_port = self.read_comport(self.usb_port["turntable"])
+
+ # Init DUT
+ wutils.wifi_test_device_init(self.dut, self.country_code)
+ self.dut.droid.bluetoothToggleState(False)
+ utils.set_location_service(self.dut, False)
+ wutils.wifi_toggle_state(self.dut, True)
+ utils.subprocess.check_output(
+ "adb root", shell=True, timeout=self.TEST_TIMEOUT)
+ utils.subprocess.check_output(
+ "adb shell settings put system screen_off_timeout 18000000",
+ shell=True,
+ timeout=self.TEST_TIMEOUT)
+ utils.subprocess.check_output(
+ "adb shell svc power stayon true",
+ shell=True,
+ timeout=self.TEST_TIMEOUT)
+
+ # create folder for rvr test result
+ self.log_path = os.path.join(logging.log_path, "rvr_results")
+ utils.create_dir(self.log_path)
+
+ Header = ("Test_date", "Project", "Device_SN", "ROM", "HW_Stage",
+ "test_SSID", "Frequency", "Turn_table_orientation",
+ "Attenuate_dB", "Signal_poll_avg_rssi", "Chain_0_rssi",
+ "Chain_1_rssi", "Link_speed", "TX_throughput_Mbps",
+ "RX_throughput_Mbps", "HE_Capable", "Country_code", "Channel",
+ "WiFi_chip", "Type", "Host_name", "AP_model",
+ "Incremental_build_id", "Build_type", "TCP_UDP_Protocol",
+ "Security_type", "Test_tool", "Airplane_mode_status", "BT_status",
+ "Bug_ID", "Comment")
+ self.csv_write(Header)
+
+ def setup_test(self):
+ self.dut.droid.wakeLockAcquireBright()
+ self.dut.droid.wakeUpNow()
+ rom_info = self.get_rominfo()
+ self.testdate = time.strftime("%Y-%m-%d", time.localtime())
+ self.rom = rom_info[0]
+ self.build_id = rom_info[1]
+ self.build_type = rom_info[2]
+ self.project = rom_info[3]
+ self.ret_country_code = self.get_country_code()
+ self.ret_hw_stage = self.get_hw_stage()
+ self.ret_platform = wperfutils.detect_wifi_platform(self.dut)
+
+ def teardown_test(self):
+ self.dut.droid.wakeLockRelease()
+ self.dut.droid.goToSleepNow()
+ wutils.set_attns(self.attenuators, "default")
+
+ def teardown_class(self):
+ if "rvr_test_params" in self.user_params:
+ self.iperf_server.stop()
+
+ def on_fail(self, test_name, begin_time):
+ self.dut.take_bug_report(test_name, begin_time)
+ self.dut.cat_adb_log(test_name, begin_time)
+
+ """Helper Functions"""
+
+ def csv_write(self, data):
+ """Output .CSV file for test result.
+
+ Args:
+ data: Dict containing attenuation, throughput and other meta data.
"""
- TEST_TIMEOUT = 10
+ with open(
+ "{}/Result.csv".format(self.log_path), "a", newline="") as csv_file:
+ csv_writer = csv.writer(csv_file, delimiter=",")
+ csv_writer.writerow(data)
+ csv_file.close()
- def setup_class(self):
- super().setup_class()
+ def set_atten(self, db):
+ """Setup attenuator dB for current test.
- self.dut = self.android_devices[0]
- wutils.wifi_test_device_init(self.dut)
+ Args:
+ db: Attenuator setup dB.
+ """
+ if db < 0:
+ db = 0
+ elif db > 95:
+ db = 95
+ self.log.info("[Attenuation] %s", "Set dB = " + str(db) + "dB")
+ for atten in self.attenuators:
+ atten.set_atten(db)
+ self.log.info("[Attenuation] %s",
+ "Current dB = " + str(atten.get_atten()) + "dB")
+ retry = 0
+ while atten.get_atten() != db and retry < 11:
+ retry = retry + 1
+ self.log.info(
+ "[Attenuation] %s", "Fail to set Attenuator to " + str(db) + ", " +
+ str(retry) + " times try to reset")
+ self.set_atten(db)
+ if retry == 11:
+ self.log.info("Attenuation] %s",
+ "Retry Attenuator fail for 10 cycles, end test!")
+ sys.exit()
- req_params = [ "iot_networks","rvr_test_params"]
- opt_params = [ "angle_params","usb_port"]
- self.unpack_userparams(req_param_names=req_params,
- opt_param_names=opt_params)
+ def read_comport(self, com):
+ """Read com port for current test.
- asserts.assert_true(
- len(self.iot_networks) > 0,
- "Need at least one iot network with psk.")
+ Args:
+ com: Serial port.
- wutils.wifi_toggle_state(self.dut, True)
- if "rvr_test_params" in self.user_params:
- self.iperf_server = self.iperf_servers[0]
- self.MaxdB= self.rvr_test_params ["rvr_atten_MaxDB"]
- self.MindB= self.rvr_test_params ["rvr_atten_MinDB"]
- self.stepdB= self.rvr_test_params ["rvr_atten_step"]
+ Returns:
+ port: Serial port with baud rate.
+ """
+ port = serial.Serial(com, 9600, timeout=1)
+ time.sleep(1)
+ return port
- if "angle_params" in self.user_params:
- self.angle = self.angle_params
+ def get_angle(self, port):
+ """Get turn table angle for current test.
- if "usb_port" in self.user_params:
- self.T1=self.readport(self.usb_port["turntable"])
- self.ATT1=self.readport(self.usb_port["atten1"])
- self.ATT2=self.readport(self.usb_port["atten2"])
- self.ATT3=self.readport(self.usb_port["atten3"])
+ Args:
+ port: Turn table com port.
- # create hashmap for testcase name and SSIDs
- self.iot_test_prefix = "test_iot_connection_to_"
- self.ssid_map = {}
- for network in self.iot_networks:
- SSID = network['SSID'].replace('-','_')
- self.ssid_map[SSID] = network
+ Returns:
+ angle: Angle from turn table.
+ """
+ angle = ""
+ port.write("DG?;".encode())
+ time.sleep(0.1)
+ degree_data = port.readline().decode("utf-8")
+ for data in range(len(degree_data)):
+ if (degree_data[data].isdigit()) is True:
+ angle = angle + degree_data[data]
+ if angle == "":
+ return -1
+ return int(angle)
- # create folder for rvr test result
- self.log_path = os.path.join(logging.log_path, "rvr_results")
- os.makedirs(self.log_path, exist_ok=True)
+ def set_angle(self, port, angle):
+ """Setup turn table angle for current test.
- Header=("test_SSID","Turn table (angle)","Attenuator(dBm)",
- "TX throughput (Mbps)","RX throughput (Mbps)",
- "RSSI","Link speed","Frequency")
- self.csv_write(Header)
+ Args:
+ port: Turn table com port
+ angle: Turn table setup angle
+ """
+ if angle > 359:
+ angle = 359
+ elif angle < 0:
+ angle = 0
+ self.log.info("Set angle to " + str(angle))
+ input_angle = str("DG") + str(angle) + str(";")
+ port.write(input_angle.encode())
+ time.sleep(self.TURN_TABLE_SETUP_TIME)
- def setup_test(self):
- self.dut.droid.wakeLockAcquireBright()
- self.dut.droid.wakeUpNow()
+ def check_angle(self, port, angle):
+ """Check turn table angle for current test.
- def teardown_test(self):
- self.dut.droid.wakeLockRelease()
- self.dut.droid.goToSleepNow()
+ Args:
+ port: Turn table com port
+ angle: Turn table setup angle
+ """
+ retrytime = self.TEST_TIMEOUT
+ retry = 0
+ while self.get_angle(port) != angle and retry < retrytime:
+ retry = retry + 1
+ self.log.info("Turntable] %s",
+ "Current angle = " + str(self.get_angle(port)))
+ self.log.info(
+ "Turntable] %s", "Fail set angle to " + str(angle) + ", " +
+ str(retry) + " times try to reset")
+ self.set_angle(port, angle)
+ time.sleep(self.TURN_TABLE_SETUP_TIME)
+ if retry == retrytime:
+ self.log.info(
+ "Turntable] %s",
+ "Retry turntable fail for " + str(retry) + " cycles, end test!")
+ sys.exit()
- def teardown_class(self):
- if "rvr_test_params" in self.user_params:
- self.iperf_server.stop()
+ def get_wifiinfo(self):
+ """Get WiFi RSSI/ link speed/ frequency for current test.
- def on_fail(self, test_name, begin_time):
- self.dut.take_bug_report(test_name, begin_time)
- self.dut.cat_adb_log(test_name, begin_time)
+ Returns:
+ [rssi,link_speed,frequency]: DUT WiFi RSSI,Link speed and Frequency.
+ """
+ def is_number(string):
+ for i in string:
+ if i.isdigit() is False:
+ if (i == "-" or i == "."):
+ continue
+ return str(-1)
+ return string
- """Helper Functions"""
+ try:
+ cmd = "adb shell iw wlan0 link"
+ wifiinfo = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
- def csv_write(self,data):
- """Output .CSV file for test result.
+ # Check RSSI Enhance
+ rssi = self.get_rssi_func()
- Args:
- data: Dict containing attenuation, throughput and other meta data.
- """
- with open("{}/Result.csv".format(self.log_path), "a", newline="") as csv_file:
- csv_writer = csv.writer(csv_file,delimiter=',')
- csv_writer.writerow(data)
- csv_file.close()
+ # Check link speed
+ link_speed = wifiinfo.decode(
+ "utf-8")[wifiinfo.decode("utf-8").find("bitrate:") +
+ 8:wifiinfo.decode("utf-8").find("Bit/s") - 2]
+ link_speed = link_speed.strip(" ")
+ link_speed = is_number(link_speed)
+ # Check frequency
+ frequency = wifiinfo.decode(
+ "utf-8")[wifiinfo.decode("utf-8").find("freq:") +
+ 6:wifiinfo.decode("utf-8").find("freq:") + 10]
+ frequency = frequency.strip(" ")
+ frequency = is_number(frequency)
+ except:
+ return -1, -1, -1
+ return [rssi, link_speed, frequency]
- def readport(self,com):
- """Read com port for current test.
+ def get_rssi_func(self):
+ """Get RSSI from brcm/qcom wifi chip.
- Args:
- com: Attenuator or turn table com port
- """
- port=serial.Serial(com,9600,timeout=1)
- time.sleep(1)
- return port
+ Returns:
+ current_rssi: DUT WiFi RSSI.
+ """
+ if self.ret_platform == "brcm":
+ rssi_future = wperfutils.get_connected_rssi_brcm(self.dut)
+ signal_poll_avg_rssi_tmp = rssi_future.pop("signal_poll_avg_rssi").pop(
+ "mean")
+ chain_0_rssi_tmp = rssi_future.pop("chain_0_rssi").pop("mean")
+ chain_1_rssi_tmp = rssi_future.pop("chain_1_rssi").pop("mean")
+ current_rssi = {
+ "signal_poll_avg_rssi": signal_poll_avg_rssi_tmp,
+ "chain_0_rssi": chain_0_rssi_tmp,
+ "chain_1_rssi": chain_1_rssi_tmp
+ }
+ elif self.ret_platform == "qcom":
+ rssi_future = wperfutils.get_connected_rssi_qcom(
+ self.dut, interface="wlan0")
+ signal_poll_avg_rssi_tmp = rssi_future.pop("signal_poll_avg_rssi").pop(
+ "mean")
+ chain_0_rssi_tmp = rssi_future.pop("chain_0_rssi").pop("mean")
+ chain_1_rssi_tmp = rssi_future.pop("chain_1_rssi").pop("mean")
+ if math.isnan(signal_poll_avg_rssi_tmp):
+ signal_poll_avg_rssi_tmp = -1
+ if math.isnan(chain_0_rssi_tmp):
+ chain_0_rssi_tmp = -1
+ if math.isnan(chain_1_rssi_tmp):
+ chain_1_rssi_tmp = -1
- def getdB(self,port):
- """Get attenuator dB for current test.
+ if signal_poll_avg_rssi_tmp == -1 & chain_0_rssi_tmp == -1 & chain_1_rssi_tmp == -1:
+ current_rssi = -1
+ else:
+ current_rssi = {
+ "signal_poll_avg_rssi": signal_poll_avg_rssi_tmp,
+ "chain_0_rssi": chain_0_rssi_tmp,
+ "chain_1_rssi": chain_1_rssi_tmp
+ }
+ else:
+ current_rssi = {
+ "signal_poll_avg_rssi": float("nan"),
+ "chain_0_rssi": float("nan"),
+ "chain_1_rssi": float("nan")
+ }
+ return current_rssi
- Args:
- port: Attenuator com port
- """
- port.write('V?;'.encode())
- dB=port.readline().decode()
- dB=dB.strip(';')
- dB=dB[dB.find('V')+1:]
- return int(dB)
+ def get_rominfo(self):
+ """Get DUT ROM build info.
- def setdB(self,port,dB):
- """Setup attenuator dB for current test.
+ Returns:
+ rom, build_id, build_type, project: DUT Build info,Build ID,
+ Build type, and Project name
+ """
+ rom = "NA"
+ build_id = "NA"
+ build_type = "NA"
+ project = "NA"
+ rominfo = self.dut.adb.shell("getprop ro.build.display.id").split()
- Args:
- port: Attenuator com port
- dB: Attenuator setup dB
- """
- if dB<0:
- dB=0
- elif dB>101:
- dB=101
- self.log.info("Set dB to "+str(dB))
- InputdB=str('V')+str(dB)+str(';')
- port.write(InputdB.encode())
- time.sleep(0.1)
+ if rominfo:
+ rom = rominfo[2]
+ build_id = rominfo[3]
+ project, build_type = rominfo[0].split("-")
- def set_Three_Att_dB(self,port1,port2,port3,dB):
- """Setup 3 attenuator dB for current test.
+ return rom, build_id, build_type, project
- Args:
- port1: Attenuator1 com port
- port1: Attenuator2 com port
- port1: Attenuator com port
- dB: Attenuator setup dB
- """
- self.setdB(port1,dB)
- self.setdB(port2,dB)
- self.setdB(port3,dB)
- self.checkdB(port1,dB)
- self.checkdB(port2,dB)
- self.checkdB(port3,dB)
+ def get_hw_stage(self):
+ """Get DUT HW stage.
- def checkdB(self,port,dB):
- """Check attenuator dB for current test.
+ Returns:
+ hw_stage: DUT HW stage e.g. EVT/DVT/PVT..etc.
+ """
+ cmd = "adb shell getprop ro.boot.hardware.revision"
+ hw_stage_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ hw_stage = hw_stage_temp.decode("utf-8").split("\n")[0]
+ return hw_stage
- Args:
- port: Attenuator com port
- dB: Attenuator setup dB
- """
- retry=0
- while self.getdB(port)!=dB and retry<10:
- retry=retry+1
- self.log.info("Current dB = "+str(self.getdB(port)))
- self.log.info("Fail to set Attenuator to "+str(dB)+", "
- +str(retry)+" times try to reset")
- self.setdB(port,dB)
- if retry ==10:
- self.log.info("Retry Attenuator fail for 9 cycles, end test!")
- sys.exit()
- return 0
+ def get_country_code(self):
+ """Get DUT country code.
- def getDG(self,port):
- """Get turn table angle for current test.
+ Returns:
+ country_code: DUT country code e.g. US/JP/GE..etc.
+ """
+ cmd = "adb shell cmd wifi get-country-code"
+ country_code_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ country_code = country_code_temp.decode("utf-8").split(" ")[4].split(
+ "\n")[0]
+ return country_code
- Args:
- port: Turn table com port
- """
- DG = ""
- port.write('DG?;'.encode())
- time.sleep(0.1)
- data = port.readline().decode('utf-8')
- for i in range(len(data)):
- if (data[i].isdigit()) == True:
- DG = DG + data[i]
- if DG == "":
- return -1
- return int(DG)
+ def get_channel(self):
+ """Get DUT WiFi channel.
- def setDG(self,port,DG):
- """Setup turn table angle for current test.
+ Returns:
+ country_code: DUT channel e.g. 6/36/37..etc.
+ """
+ if self.ret_platform == "brcm":
+ cmd = 'adb shell wl assoc | grep "Primary channel:"'
+ channel_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ channel = channel_temp.decode("utf-8").split(": ")[1].split("\n")[0]
+ elif self.ret_platform == "qcom":
+ cmd = "adb shell iw wlan0 info | grep channel"
+ channel_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ channel = channel_temp.decode("utf-8").split(" ")[1].split("\n")[0]
+ return channel
- Args:
- port: Turn table com port
- DG: Turn table setup angle
- """
- if DG>359:
- DG=359
- elif DG<0:
- DG=0
- self.log.info("Set angle to "+str(DG))
- InputDG=str('DG')+str(DG)+str(';')
- port.write(InputDG.encode())
+ def get_he_capable(self):
+ """Get DUT WiFi high efficiency capable status .
- def checkDG(self,port,DG):
- """Check turn table angle for current test.
+ Returns:
+ he_capable: DUT high efficiency capable status.
+ """
+ if self.ret_platform == "brcm":
+ cmd = 'adb shell wl assoc | grep "Chanspec:"'
+ he_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ he_capable = he_temp.decode("utf-8").split(": ")[1].split("\n")[0].split(
+ "MHz")[0].split(" ")[3]
+ elif self.ret_platform == "qcom":
+ cmd = "adb shell iw wlan0 info | grep channel"
+ he_temp = utils.subprocess.check_output(
+ cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ he_capable = he_temp.decode("utf-8").split("width: ")[1].split(" ")[0]
+ return he_capable
- Args:
- port: Turn table com port
- DG: Turn table setup angle
- """
- retrytime = self.TEST_TIMEOUT
- retry = 0
- while self.getDG(port)!=DG and retry<retrytime:
- retry=retry+1
- self.log.info('Current angle = '+str(self.getDG(port)))
- self.log.info('Fail set angle to '+str(DG)+', '+str(retry)+' times try to reset')
- self.setDG(port,DG)
- time.sleep(10)
- if retry == retrytime:
- self.log.info('Retry turntable fail for '+str(retry)+' cycles, end test!')
- sys.exit()
- return 0
+ def post_process_results(self, rvr_result):
+ """Saves JSON formatted results.
- def getwifiinfo(self):
- """Get WiFi RSSI/ link speed/ frequency for current test.
+ Args:
+ rvr_result: Dict containing attenuation, throughput and other meta data
+ Returns:
+ wifiinfo[0]: To check WiFi connection by RSSI value
+ """
+ # Save output as text file
+ wifiinfo = self.get_wifiinfo()
+ if wifiinfo[0] != -1:
+ rvr_result["signal_poll_avg_rssi"] = wifiinfo[0]["signal_poll_avg_rssi"]
+ rvr_result["chain_0_rssi"] = wifiinfo[0]["chain_0_rssi"]
+ rvr_result["chain_1_rssi"] = wifiinfo[0]["chain_1_rssi"]
+ else:
+ rvr_result["signal_poll_avg_rssi"] = wifiinfo[0]
+ rvr_result["chain_0_rssi"] = wifiinfo[0]
+ rvr_result["chain_1_rssi"] = wifiinfo[0]
+ if rvr_result["signal_poll_avg_rssi"] == -1:
+ rvr_result["channel"] = "NA"
+ else:
+ rvr_result["channel"] = self.ret_channel
+ rvr_result["country_code"] = self.ret_country_code
+ rvr_result["hw_stage"] = self.ret_hw_stage
+ rvr_result["wifi_chip"] = self.ret_platform
+ rvr_result["test_ssid"] = self.ssid
+ rvr_result["test_angle"] = self.angle_list[self.angle]
+ rvr_result["test_dB"] = self.db
+ rvr_result["test_link_speed"] = wifiinfo[1]
+ rvr_result["test_frequency"] = wifiinfo[2]
- Returns:
- [RSSI,LS,FR]: WiFi RSSI/ link speed/ frequency
- """
- def is_number(string):
- for i in string:
- if i.isdigit() == False:
- if (i=="-" or i=="."):
- continue
- return str(-1)
- return string
+ data = (
+ self.testdate,
+ self.project,
+ self.dut.serial,
+ self.rom,
+ rvr_result["hw_stage"],
+ rvr_result["test_ssid"],
+ rvr_result["test_frequency"],
+ rvr_result["test_angle"],
+ rvr_result["test_dB"],
+ rvr_result["signal_poll_avg_rssi"],
+ rvr_result["chain_0_rssi"],
+ rvr_result["chain_1_rssi"],
+ rvr_result["test_link_speed"],
+ rvr_result["throughput_TX"][0],
+ rvr_result["throughput_RX"][0],
+ "HE" + self.he_capable,
+ rvr_result["country_code"],
+ rvr_result["channel"],
+ rvr_result["wifi_chip"],
+ "OTA_RvR",
+ "OTA_Testbed2",
+ "RAXE500",
+ self.build_id,
+ self.build_type,
+ "TCP",
+ "WPA3",
+ "iperf3",
+ "OFF",
+ "OFF",
+ )
+ self.csv_write(data)
- try:
- cmd = "adb shell iw wlan0 link"
- wifiinfo = utils.subprocess.check_output(cmd,shell=True,
- timeout=self.TEST_TIMEOUT)
- # Check RSSI
- RSSI = wifiinfo.decode("utf-8")[wifiinfo.decode("utf-8").find("signal:") +
- 7:wifiinfo.decode("utf-8").find("dBm") - 1]
- RSSI = RSSI.strip(' ')
- RSSI = is_number(RSSI)
- # Check link speed
- LS = wifiinfo.decode("utf-8")[wifiinfo.decode("utf-8").find("bitrate:") +
- 8:wifiinfo.decode("utf-8").find("Bit/s") - 2]
- LS = LS.strip(' ')
- LS = is_number(LS)
- # Check frequency
- FR = wifiinfo.decode("utf-8")[wifiinfo.decode("utf-8").find("freq:") +
- 6:wifiinfo.decode("utf-8").find("freq:") + 10]
- FR = FR.strip(' ')
- FR = is_number(FR)
- except:
- return -1, -1, -1
- return [RSSI,LS,FR]
+ results_file_path = "{}/{}_angle{}_{}dB.json".format(
+ self.log_path, self.ssid, self.angle_list[self.angle], self.db)
+ with open(results_file_path, "w") as results_file:
+ json.dump(rvr_result, results_file, indent=4)
+ return wifiinfo[0]
- def post_process_results(self, rvr_result):
- """Saves JSON formatted results.
+ def connect_to_wifi_network(self, network):
+ """Connection logic for wifi networks.
- Args:
- rvr_result: Dict containing attenuation, throughput and other meta
- data
- """
- # Save output as text file
- data=(rvr_result["test_name"],rvr_result["test_angle"],rvr_result["test_dB"],
- rvr_result["throughput_TX"][0],rvr_result["throughput_RX"][0],
- rvr_result["test_RSSI"],rvr_result["test_LS"],rvr_result["test_FR"])
- self.csv_write(data)
+ Args:
+ params: Dictionary with network info.
+ """
+ ssid = network[WifiEnums.SSID_KEY]
+ self.dut.ed.clear_all_events()
+ wutils.start_wifi_connection_scan(self.dut)
+ scan_results = self.dut.droid.wifiGetScanResults()
+ wutils.assert_network_in_list({WifiEnums.SSID_KEY: ssid}, scan_results)
+ wutils.wifi_connect(self.dut, network, num_of_tries=3)
- results_file_path = "{}/{}_angle{}_{}dB.json".format(self.log_path,
- self.ssid,
- self.angle[self.ag],self.DB)
- with open(results_file_path, 'w') as results_file:
- json.dump(rvr_result, results_file, indent=4)
+ def run_iperf_init(self, network):
+ self.iperf_server.start(tag="init")
+ self.log.info("[Iperf] %s", "Starting iperf traffic init.")
+ time.sleep(self.IPERF_SETUP_TIME)
+ try:
+ port_arg = "-p {} -J -R -t10".format(self.iperf_server.port)
+ self.dut.run_iperf_client(
+ self.rvr_test_params["iperf_server_address"],
+ port_arg,
+ timeout=self.rvr_test_params["iperf_duration"] + self.TEST_TIMEOUT)
+ self.iperf_server.stop()
+ self.log.info("[Iperf] %s", "iperf traffic init Pass")
+ except:
+ self.log.warning("ValueError: iperf init ERROR.")
- def connect_to_wifi_network(self, network):
- """Connection logic for psk wifi networks.
+ def run_iperf_client(self, network):
+ """Run iperf TX throughput after connection.
- Args:
- params: Dictionary with network info.
- """
- SSID = network[WifiEnums.SSID_KEY]
- self.dut.ed.clear_all_events()
- wutils.start_wifi_connection_scan(self.dut)
- scan_results = self.dut.droid.wifiGetScanResults()
- wutils.assert_network_in_list({WifiEnums.SSID_KEY: SSID}, scan_results)
- wutils.wifi_connect(self.dut, network, num_of_tries=3)
+ Args:
+ network: Dictionary with network info.
- def run_iperf_client(self, network):
- """Run iperf TX throughput after connection.
+ Returns:
+ rvr_result: Dict containing TX rvr_results.
+ """
+ rvr_result = []
+ try:
+ self.iperf_server.start(tag="TX_server_{}_angle{}_{}dB".format(
+ self.ssid, self.angle_list[self.angle], self.db))
+ ssid = network[WifiEnums.SSID_KEY]
+ self.log.info("[Iperf] %s",
+ "Starting iperf traffic TX through {}".format(ssid))
+ time.sleep(self.IPERF_SETUP_TIME)
+ port_arg = "-p {} -J {}".format(self.iperf_server.port,
+ self.rvr_test_params["iperf_port_arg"])
+ success, data = self.dut.run_iperf_client(
+ self.rvr_test_params["iperf_server_address"],
+ port_arg,
+ timeout=self.rvr_test_params["iperf_duration"] + self.TEST_TIMEOUT)
+ # Parse and log result
+ client_output_path = os.path.join(
+ self.iperf_server.log_path,
+ "IperfDUT,{},TX_client_{}_angle{}_{}dB".format(
+ self.iperf_server.port, self.ssid, self.angle_list[self.angle],
+ self.db))
+ with open(client_output_path, "w") as out_file:
+ out_file.write("\n".join(data))
+ self.iperf_server.stop()
- Args:
- params: Dictionary with network info.
+ iperf_file = self.iperf_server.log_files[-1]
+ iperf_result = ipf.IPerfResult(iperf_file)
+ curr_throughput = (math.fsum(iperf_result.instantaneous_rates[
+ self.rvr_test_params["iperf_ignored_interval"]:-1]) /
+ len(iperf_result.instantaneous_rates[
+ self.rvr_test_params["iperf_ignored_interval"]:-1])
+ ) * 8 * (1.024**2)
+ rvr_result.append(curr_throughput)
+ self.log.info(
+ "[Iperf] %s", "TX Throughput at {0:.2f} dB is {1:.2f} Mbps".format(
+ self.db, curr_throughput))
+ self.log.debug(pprint.pformat(data))
+ asserts.assert_true(success, "Error occurred in iPerf traffic.")
+ return rvr_result
+ except:
+ rvr_result = ["NA"]
+ self.log.warning("ValueError: TX iperf ERROR.")
+ self.iperf_server.stop()
+ return rvr_result
- Returns:
- rvr_result: Dict containing rvr_results
- """
- rvr_result = []
- self.iperf_server.start(tag="TX_server_{}_angle{}_{}dB".format(
- self.ssid,self.angle[self.ag],self.DB))
- wait_time = 5
- SSID = network[WifiEnums.SSID_KEY]
- self.log.info("Starting iperf traffic TX through {}".format(SSID))
- time.sleep(wait_time)
- port_arg = "-p {} -J {}".format(self.iperf_server.port,
- self.rvr_test_params["iperf_port_arg"])
- success, data = self.dut.run_iperf_client(
- self.rvr_test_params["iperf_server_address"],
- port_arg,
- timeout=self.rvr_test_params["iperf_duration"] + self.TEST_TIMEOUT)
- # Parse and log result
- client_output_path = os.path.join(
- self.iperf_server.log_path, "IperfDUT,{},TX_client_{}_angle{}_{}dB".format(
- self.iperf_server.port,self.ssid,self.angle[self.ag],self.DB))
- with open(client_output_path, 'w') as out_file:
- out_file.write("\n".join(data))
- self.iperf_server.stop()
+ def run_iperf_server(self, network):
+ """Run iperf RX throughput after connection.
- iperf_file = self.iperf_server.log_files[-1]
- try:
- iperf_result = ipf.IPerfResult(iperf_file)
- curr_throughput = (math.fsum(iperf_result.instantaneous_rates[
- self.rvr_test_params["iperf_ignored_interval"]:-1]) / len(
- iperf_result.instantaneous_rates[self.rvr_test_params[
- "iperf_ignored_interval"]:-1])) * 8 * (1.024**2)
- except:
- self.log.warning(
- "ValueError: Cannot get iperf result. Setting to 0")
- curr_throughput = 0
- rvr_result.append(curr_throughput)
- self.log.info("TX Throughput at {0:.2f} dB is {1:.2f} Mbps".format(
- self.DB, curr_throughput))
+ Args:
+ network: Dictionary with network info.
- self.log.debug(pprint.pformat(data))
- asserts.assert_true(success, "Error occurred in iPerf traffic.")
- return rvr_result
+ Returns:
+ rvr_result: Dict containing RX rvr_results.
+ """
- def run_iperf_server(self, network):
- """Run iperf RX throughput after connection.
+ rvr_result = []
+ try:
+ self.iperf_server.start(tag="RX_client_{}_angle{}_{}dB".format(
+ self.ssid, self.angle_list[self.angle], self.db))
+ ssid = network[WifiEnums.SSID_KEY]
+ self.log.info("[Iperf] %s",
+ "Starting iperf traffic RX through {}".format(ssid))
+ time.sleep(self.IPERF_SETUP_TIME)
+ port_arg = "-p {} -J -R {}".format(self.iperf_server.port,
+ self.rvr_test_params["iperf_port_arg"])
+ success, data = self.dut.run_iperf_client(
+ self.rvr_test_params["iperf_server_address"],
+ port_arg,
+ timeout=self.rvr_test_params["iperf_duration"] + self.TEST_TIMEOUT)
+ # Parse and log result
+ client_output_path = os.path.join(
+ self.iperf_server.log_path,
+ "IperfDUT,{},RX_server_{}_angle{}_{}dB".format(
+ self.iperf_server.port, self.ssid, self.angle_list[self.angle],
+ self.db))
+ with open(client_output_path, "w") as out_file:
+ out_file.write("\n".join(data))
+ self.iperf_server.stop()
- Args:
- params: Dictionary with network info.
+ iperf_file = client_output_path
+ iperf_result = ipf.IPerfResult(iperf_file)
+ curr_throughput = (math.fsum(iperf_result.instantaneous_rates[
+ self.rvr_test_params["iperf_ignored_interval"]:-1]) /
+ len(iperf_result.instantaneous_rates[
+ self.rvr_test_params["iperf_ignored_interval"]:-1])
+ ) * 8 * (1.024**2)
+ rvr_result.append(curr_throughput)
+ self.log.info(
+ "[Iperf] %s", "RX Throughput at {0:.2f} dB is {1:.2f} Mbps".format(
+ self.db, curr_throughput))
- Returns:
- rvr_result: Dict containing rvr_results
- """
- rvr_result = []
- self.iperf_server.start(tag="RX_client_{}_angle{}_{}dB".format(
- self.ssid,self.angle[self.ag],self.DB))
- wait_time = 5
- SSID = network[WifiEnums.SSID_KEY]
- self.log.info("Starting iperf traffic RX through {}".format(SSID))
- time.sleep(wait_time)
- port_arg = "-p {} -J -R {}".format(self.iperf_server.port,
- self.rvr_test_params["iperf_port_arg"])
- success, data = self.dut.run_iperf_client(
- self.rvr_test_params["iperf_server_address"],
- port_arg,
- timeout=self.rvr_test_params["iperf_duration"] + self.TEST_TIMEOUT)
- # Parse and log result
- client_output_path = os.path.join(
- self.iperf_server.log_path, "IperfDUT,{},RX_server_{}_angle{}_{}dB".format(
- self.iperf_server.port,self.ssid,self.angle[self.ag],self.DB))
- with open(client_output_path, 'w') as out_file:
- out_file.write("\n".join(data))
- self.iperf_server.stop()
+ self.log.debug(pprint.pformat(data))
+ asserts.assert_true(success, "Error occurred in iPerf traffic.")
+ return rvr_result
+ except:
+ rvr_result = ["NA"]
+ self.log.warning("ValueError: RX iperf ERROR.")
+ self.iperf_server.stop()
+ return rvr_result
- iperf_file = client_output_path
- try:
- iperf_result = ipf.IPerfResult(iperf_file)
- curr_throughput = (math.fsum(iperf_result.instantaneous_rates[
- self.rvr_test_params["iperf_ignored_interval"]:-1]) / len(
- iperf_result.instantaneous_rates[self.rvr_test_params[
- "iperf_ignored_interval"]:-1])) * 8 * (1.024**2)
- except:
- self.log.warning(
- "ValueError: Cannot get iperf result. Setting to 0")
- curr_throughput = 0
- rvr_result.append(curr_throughput)
- self.log.info("RX Throughput at {0:.2f} dB is {1:.2f} Mbps".format(
- self.DB, curr_throughput))
+ def iperf_test_func(self, network):
+ """Main function to test iperf TX/RX.
- self.log.debug(pprint.pformat(data))
- asserts.assert_true(success, "Error occurred in iPerf traffic.")
- return rvr_result
+ Args:
+ network: Dictionary with network info.
+ """
+ # Initialize
+ rvr_result = {}
+ # Run RvR and log result
+ rvr_result["throughput_RX"] = self.run_iperf_server(network)
+ retry_time = 2
+ for retry in range(retry_time):
+ if rvr_result["throughput_RX"] == ["NA"]:
+ if not self.iperf_retry():
+ time.sleep(self.IPERF_SETUP_TIME)
+ rvr_result["throughput_RX"] = self.run_iperf_server(network)
+ else:
+ break
+ else:
+ break
+ rvr_result["throughput_TX"] = self.run_iperf_client(network)
+ retry_time = 2
+ for retry in range(retry_time):
+ if rvr_result["throughput_TX"] == ["NA"]:
+ if not self.iperf_retry():
+ time.sleep(self.IPERF_SETUP_TIME)
+ rvr_result["throughput_TX"] = self.run_iperf_client(network)
+ else:
+ break
+ else:
+ break
+ self.post_process_results(rvr_result)
+ self.rssi = wifiinfo[0]
+ return self.rssi
- def iperf_test_func(self,network):
- """Main function to test iperf TX/RX.
+ def iperf_retry(self):
+ """Check iperf TX/RX status and retry."""
+ try:
+ cmd = "adb -s {} shell pidof iperf3| xargs adb shell kill -9".format(
+ self.dut.serial)
+ utils.subprocess.call(cmd, shell=True, timeout=self.TEST_TIMEOUT)
+ self.log.warning("ValueError: Killed DUT iperf process, keep test")
+ except:
+ self.log.info("[Iperf] %s", "No iperf DUT process found, keep test")
- Args:
- params: Dictionary with network info
- """
- if "rvr_test_params" in self.user_params:
- # Initialize
- rvr_result = {}
- # Run RvR and log result
- wifiinfo = self.getwifiinfo()
- rvr_result["throughput_TX"] = self.run_iperf_client(network)
- rvr_result["throughput_RX"] = self.run_iperf_server(network)
- rvr_result["test_name"] = self.ssid
- rvr_result["test_angle"] = self.angle[self.ag]
- rvr_result["test_dB"] = self.DB
- rvr_result["test_RSSI"] = wifiinfo[0]
- rvr_result["test_LS"] = wifiinfo[1]
- rvr_result["test_FR"] = wifiinfo[2]
- self.post_process_results(rvr_result)
+ wifiinfo = self.get_wifiinfo()
+ print("--[iperf_retry]--", wifiinfo[0])
+ self.log.info("[WiFiinfo] %s", "Current RSSI = " + str(wifiinfo[0]) + "dBm")
+ if wifiinfo[0] == -1:
+ self.log.warning("ValueError: Cannot get RSSI, stop throughput test")
+ return True
+ else:
+ return False
- def rvr_test(self,network):
- """Test function to run RvR.
+ def rvr_test(self, network):
+ """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
+ 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:
- params: Dictionary with network info
- """
- wait_time = 5
- utils.subprocess.check_output('adb root', shell=True, timeout=20)
- self.ssid = network[WifiEnums.SSID_KEY]
- self.log.info("Start rvr test")
- for i in range(len(self.angle)):
- self.setDG(self.T1,self.angle[i])
- time.sleep(wait_time)
- self.checkDG(self.T1,self.angle[i])
- self.set_Three_Att_dB(self.ATT1,self.ATT2,self.ATT3,0)
- time.sleep(wait_time)
- self.connect_to_wifi_network(network)
- self.set_Three_Att_dB(self.ATT1,self.ATT2,self.ATT3,self.MindB)
- for j in range(self.MindB,self.MaxdB+self.stepdB,self.stepdB):
- self.DB=j
- self.ag=i
- self.set_Three_Att_dB(self.ATT1,self.ATT2,self.ATT3,self.DB)
- self.iperf_test_func(network)
- wutils.reset_wifi(self.dut)
+ Args:
+ params: Dictionary with network info
+ """
+ self.ssid = network[WifiEnums.SSID_KEY]
+ self.log.info("Start rvr test")
- """Tests"""
+ for angle in range(len(self.angle_list)):
+ self.angle = angle
+ self.set_angle(self.turntable_port, self.angle_list[angle])
+ self.check_angle(self.turntable_port, self.angle_list[angle])
+ self.set_atten(0)
+ self.connect_to_wifi_network(network)
+ self.ret_channel = self.get_channel()
+ self.he_capable = self.get_he_capable()
+ self.run_iperf_init(network)
+ for db in range(self.mindb, self.maxdb + self.stepdb, self.stepdb):
+ self.db = db
+ self.set_atten(self.db)
+ self.iperf_test_func(network)
+ if self.rssi == -1:
+ self.log.warning("ValueError: Cannot get RSSI. Run next angle")
+ break
+ else:
+ continue
+ wutils.reset_wifi(self.dut)
- @test_tracker_info(uuid="93816af8-4c63-45f8-b296-cb49fae0b158")
- def test_iot_connection_to_RVR_2G(self):
- ssid_key = self.current_test_name.replace(self.iot_test_prefix, "")
- self.rvr_test(self.ssid_map[ssid_key])
+ """Tests"""
+ def test_rvr_2g(self):
+ network = self.rvr_networks[0]
+ self.rvr_test(network)
- @test_tracker_info(uuid="e1a67e13-946f-4d91-aa73-3f945438a1ac")
- def test_iot_connection_to_RVR_5G(self):
- ssid_key = self.current_test_name.replace(self.iot_test_prefix, "")
- self.rvr_test(self.ssid_map[ssid_key])
\ No newline at end of file
+ def test_rvr_5g(self):
+ network = self.rvr_networks[1]
+ self.rvr_test(network)
+
+ def test_rvr_6g(self):
+ network = self.rvr_networks[2]
+ self.rvr_test(network)
diff --git a/acts_tests/tests/google/wifi/WifiSensitivityTest.py b/acts_tests/tests/google/wifi/WifiSensitivityTest.py
index 954bc90..535572d 100644
--- a/acts_tests/tests/google/wifi/WifiSensitivityTest.py
+++ b/acts_tests/tests/google/wifi/WifiSensitivityTest.py
@@ -375,18 +375,21 @@
self.testbed_params['ap_tx_power_offset'][str(
testcase_params['channel'])] - ping_result['range'])
- def setup_sensitivity_test(self, testcase_params):
- # Setup test
- if testcase_params['traffic_type'].lower() == 'ping':
- self.setup_ping_test(testcase_params)
- self.run_sensitivity_test = self.run_ping_test
- self.process_sensitivity_test_results = (
- self.process_ping_test_results)
- else:
- self.setup_rvr_test(testcase_params)
- self.run_sensitivity_test = self.run_rvr_test
- self.process_sensitivity_test_results = (
- self.process_rvr_test_results)
+ def setup_ping_test(self, testcase_params):
+ """Function that gets devices ready for the test.
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ """
+ # Configure AP
+ self.setup_ap(testcase_params)
+ # Set attenuator to starting attenuation
+ for attenuator in self.attenuators:
+ attenuator.set_atten(testcase_params['atten_start'],
+ strict=False,
+ retry=True)
+ # Reset, configure, and connect DUT
+ self.setup_dut(testcase_params)
def setup_ap(self, testcase_params):
"""Sets up the AP and attenuator to compensate for AP chain imbalance.
@@ -586,9 +589,14 @@
]
# Prepare devices and run test
- self.setup_sensitivity_test(testcase_params)
- result = self.run_sensitivity_test(testcase_params)
- self.process_sensitivity_test_results(testcase_params, result)
+ if testcase_params['traffic_type'].lower() == 'ping':
+ self.setup_ping_test(testcase_params)
+ result = self.run_ping_test(testcase_params)
+ self.process_ping_test_results(testcase_params, result)
+ else:
+ self.setup_rvr_test(testcase_params)
+ result = self.run_rvr_test(testcase_params)
+ self.process_rvr_test_results(testcase_params, result)
# Post-process results
self.testclass_results.append(result)
@@ -644,6 +652,7 @@
class WifiSensitivity_AllChannels_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -652,6 +661,7 @@
class WifiSensitivity_SampleChannels_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases([6, 36, 149],
@@ -660,6 +670,7 @@
class WifiSensitivity_2GHz_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases([1, 2, 6, 10, 11], ['VHT20'],
@@ -667,6 +678,7 @@
class WifiSensitivity_5GHz_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
@@ -675,6 +687,7 @@
class WifiSensitivity_UNII1_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases([36, 40, 44, 48],
@@ -683,6 +696,7 @@
class WifiSensitivity_UNII3_Test(WifiSensitivityTest):
+
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases([149, 153, 157, 161],
@@ -698,6 +712,7 @@
It allows setting orientation and other chamber parameters to study
performance in varying channel conditions
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
self.testcase_metric_logger = (
@@ -911,6 +926,7 @@
class WifiOtaSensitivity_TenDegree_Test(WifiOtaSensitivityTest):
+
def __init__(self, controllers):
WifiOtaSensitivityTest.__init__(self, controllers)
requested_channels = [6, 36, 149]
@@ -929,6 +945,7 @@
class WifiOtaSensitivity_PerChain_TenDegree_Test(WifiOtaSensitivityTest):
+
def __init__(self, controllers):
WifiOtaSensitivityTest.__init__(self, controllers)
requested_channels = [6, 36, 149]
@@ -947,6 +964,7 @@
class WifiOtaSensitivity_ThirtyDegree_Test(WifiOtaSensitivityTest):
+
def __init__(self, controllers):
WifiOtaSensitivityTest.__init__(self, controllers)
requested_channels = [6, 36, 149]
@@ -971,6 +989,7 @@
class WifiOtaSensitivity_45Degree_Test(WifiOtaSensitivityTest):
+
def __init__(self, controllers):
WifiOtaSensitivityTest.__init__(self, controllers)
requested_rates = [
diff --git a/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py b/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
index a8d9628..ddd25f7 100644
--- a/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
+++ b/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
@@ -50,6 +50,7 @@
example config file to run this test class see
example_connectivity_performance_ap_sta.json.
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
# Define metrics to be uploaded to BlackBox
@@ -125,6 +126,7 @@
except:
self.log.warning('Could not start sniffer. Disabling sniffs.')
self.testbed_params['sniffer_enable'] = 0
+ self.sniffer_subsampling = 1
self.log_path = os.path.join(logging.log_path, 'test_results')
os.makedirs(self.log_path, exist_ok=True)
self.log.info('Access Point Configuration: {}'.format(
@@ -159,44 +161,18 @@
test_result_dict: dict containing attenuation, throughput and other
meta data
"""
- avg_throughput = test_result['iperf_summary']['avg_throughput']
- min_throughput = test_result['iperf_summary']['min_throughput']
- std_dev_percent = (
- test_result['iperf_summary']['std_deviation'] /
- test_result['iperf_summary']['avg_throughput']) * 100
- # Set blackbox metrics
- if self.publish_testcase_metrics:
- self.testcase_metric_logger.add_metric('avg_throughput',
- avg_throughput)
- self.testcase_metric_logger.add_metric('min_throughput',
- min_throughput)
- self.testcase_metric_logger.add_metric('std_dev_percent',
- std_dev_percent)
# Evaluate pass/fail
min_throughput_check = (
- (min_throughput / avg_throughput) *
+ (test_result['iperf_summary']['min_throughput'] /
+ test_result['iperf_summary']['avg_throughput']) *
100) > self.testclass_params['min_throughput_threshold']
- std_deviation_check = std_dev_percent < self.testclass_params[
- 'std_deviation_threshold']
+ std_deviation_check = test_result['iperf_summary'][
+ 'std_dev_percent'] < self.testclass_params[
+ 'std_deviation_threshold']
- llstats = (
- 'TX MCS = {0} ({1:.1f}%). '
- 'RX MCS = {2} ({3:.1f}%)'.format(
- test_result['llstats']['summary']['common_tx_mcs'],
- test_result['llstats']['summary']['common_tx_mcs_freq'] * 100,
- test_result['llstats']['summary']['common_rx_mcs'],
- test_result['llstats']['summary']['common_rx_mcs_freq'] * 100))
-
- test_message = (
- 'Atten: {0:.2f}dB, RSSI: {1:.2f}dB. '
- 'Throughput (Mean: {2:.2f}, Std. Dev:{3:.2f}%, Min: {4:.2f} Mbps).'
- 'LLStats : {5}'.format(
- test_result['attenuation'],
- test_result['rssi_result']['signal_poll_rssi']['mean'],
- avg_throughput, std_dev_percent, min_throughput, llstats))
if min_throughput_check and std_deviation_check:
- asserts.explicit_pass('Test Passed.' + test_message)
- asserts.fail('Test Failed. ' + test_message)
+ asserts.explicit_pass('Test Passed.')
+ asserts.fail('Test Failed.')
def post_process_results(self, test_result):
"""Extracts results and saves plots and JSON formatted results.
@@ -209,41 +185,37 @@
avg throughput, other metrics, and other meta data
"""
# Save output as text file
- test_name = self.current_test_name
- results_file_path = os.path.join(self.log_path,
- '{}.txt'.format(test_name))
- if test_result['iperf_result'].instantaneous_rates:
- instantaneous_rates_Mbps = [
- rate * 8 * (1.024**2)
- for rate in test_result['iperf_result'].instantaneous_rates[
- self.testclass_params['iperf_ignored_interval']:-1]
- ]
- tput_standard_deviation = test_result[
- 'iperf_result'].get_std_deviation(
- self.testclass_params['iperf_ignored_interval']) * 8
- else:
- instantaneous_rates_Mbps = [float('nan')]
- tput_standard_deviation = float('nan')
- test_result['iperf_summary'] = {
- 'instantaneous_rates': instantaneous_rates_Mbps,
- 'avg_throughput': numpy.mean(instantaneous_rates_Mbps),
- 'std_deviation': tput_standard_deviation,
- 'min_throughput': min(instantaneous_rates_Mbps)
- }
+ results_file_path = os.path.join(
+ self.log_path, '{}.txt'.format(self.current_test_name))
with open(results_file_path, 'w') as results_file:
json.dump(wputils.serialize_dict(test_result), results_file)
# Plot and save
- figure = BokehFigure(test_name,
- x_label='Time (s)',
- primary_y_label='Throughput (Mbps)')
- time_data = list(range(0, len(instantaneous_rates_Mbps)))
- figure.add_line(time_data,
- instantaneous_rates_Mbps,
- legend=self.current_test_name,
- marker='circle')
- output_file_path = os.path.join(self.log_path,
- '{}.html'.format(test_name))
- figure.generate_figure(output_file_path)
+ # Set blackbox metrics
+ if self.publish_testcase_metrics:
+ self.testcase_metric_logger.add_metric(
+ 'avg_throughput',
+ test_result['iperf_summary']['avg_throughput'])
+ self.testcase_metric_logger.add_metric(
+ 'min_throughput',
+ test_result['iperf_summary']['min_throughput'])
+ self.testcase_metric_logger.add_metric(
+ 'std_dev_percent',
+ test_result['iperf_summary']['std_dev_percent'])
+ figure = BokehFigure(self.current_test_name,
+ x_label='Time (s)',
+ primary_y_label='Throughput (Mbps)')
+ time_data = list(
+ range(
+ 0,
+ len(test_result['iperf_summary']['instantaneous_rates'])))
+ figure.add_line(
+ time_data,
+ test_result['iperf_summary']['instantaneous_rates'],
+ legend=self.current_test_name,
+ marker='circle')
+ output_file_path = os.path.join(
+ self.log_path, '{}.html'.format(self.current_test_name))
+ figure.generate_figure(output_file_path)
return test_result
def setup_ap(self, testcase_params):
@@ -352,9 +324,11 @@
# Run test and log result
# Start iperf session
self.log.info('Starting iperf test.')
+ test_result = collections.OrderedDict()
llstats_obj = wputils.LinkLayerStats(self.dut)
llstats_obj.update_stats()
- if self.testbed_params['sniffer_enable']:
+ if self.testbed_params['sniffer_enable'] and len(
+ self.testclass_results) % self.sniffer_subsampling == 0:
self.sniffer.start_capture(
network=testcase_params['test_network'],
chan=testcase_params['channel'],
@@ -375,7 +349,8 @@
current_rssi = current_rssi.result()
server_output_path = self.iperf_server.stop()
# Stop sniffer
- if self.testbed_params['sniffer_enable']:
+ if self.testbed_params['sniffer_enable'] and len(
+ self.testclass_results) % self.sniffer_subsampling == 0:
self.sniffer.stop_capture()
# Set attenuator to 0 dB
for attenuator in self.attenuators:
@@ -388,16 +363,61 @@
try:
iperf_result = ipf.IPerfResult(iperf_file)
except:
- asserts.fail('Cannot get iperf result.')
+ iperf_result = ipf.IPerfResult('{}') #empty iperf result
+ self.log.warning('Cannot get iperf result.')
+ if iperf_result.instantaneous_rates:
+ instantaneous_rates_Mbps = [
+ rate * 8 * (1.024**2)
+ for rate in iperf_result.instantaneous_rates[
+ self.testclass_params['iperf_ignored_interval']:-1]
+ ]
+ tput_standard_deviation = iperf_result.get_std_deviation(
+ self.testclass_params['iperf_ignored_interval']) * 8
+ else:
+ instantaneous_rates_Mbps = [float('nan')]
+ tput_standard_deviation = float('nan')
+ test_result['iperf_summary'] = {
+ 'instantaneous_rates':
+ instantaneous_rates_Mbps,
+ 'avg_throughput':
+ numpy.mean(instantaneous_rates_Mbps),
+ 'std_deviation':
+ tput_standard_deviation,
+ 'min_throughput':
+ min(instantaneous_rates_Mbps),
+ 'std_dev_percent':
+ (tput_standard_deviation / numpy.mean(instantaneous_rates_Mbps)) *
+ 100
+ }
llstats_obj.update_stats()
curr_llstats = llstats_obj.llstats_incremental.copy()
- test_result = collections.OrderedDict()
test_result['testcase_params'] = testcase_params.copy()
test_result['ap_settings'] = self.access_point.ap_settings.copy()
test_result['attenuation'] = testcase_params['atten_level']
test_result['iperf_result'] = iperf_result
test_result['rssi_result'] = current_rssi
test_result['llstats'] = curr_llstats
+
+ llstats = (
+ 'TX MCS = {0} ({1:.1f}%). '
+ 'RX MCS = {2} ({3:.1f}%)'.format(
+ test_result['llstats']['summary']['common_tx_mcs'],
+ test_result['llstats']['summary']['common_tx_mcs_freq'] * 100,
+ test_result['llstats']['summary']['common_rx_mcs'],
+ test_result['llstats']['summary']['common_rx_mcs_freq'] * 100))
+
+ test_message = (
+ 'Atten: {0:.2f}dB, RSSI: {1:.2f}dB. '
+ 'Throughput (Mean: {2:.2f}, Std. Dev:{3:.2f}%, Min: {4:.2f} Mbps).'
+ 'LLStats : {5}'.format(
+ test_result['attenuation'],
+ test_result['rssi_result']['signal_poll_rssi']['mean'],
+ test_result['iperf_summary']['avg_throughput'],
+ test_result['iperf_summary']['std_dev_percent'],
+ test_result['iperf_summary']['min_throughput'], llstats))
+
+ self.log.info(test_message)
+
self.testclass_results.append(test_result)
return test_result
@@ -501,6 +521,7 @@
setting turntable orientation and other chamber parameters to study
performance in varying channel conditions
"""
+
def __init__(self, controllers):
base_test.BaseTestClass.__init__(self, controllers)
# Define metrics to be uploaded to BlackBox
@@ -605,6 +626,22 @@
test_atten = self.testclass_params['ota_atten_levels'][band][1]
return test_atten
+ def _test_throughput_stability_over_orientation(self, testcase_params):
+ """ Function that gets called for each test case
+
+ The function gets called in each test case. The function customizes
+ the test based on the test name of the test that called it
+
+ Args:
+ testcase_params: dict containing test specific parameters
+ """
+ testcase_params = self.compile_test_params(testcase_params)
+ for position in testcase_params['positions']:
+ testcase_params['position'] = position
+ self.setup_throughput_stability_test(testcase_params)
+ test_result = self.run_throughput_stability_test(testcase_params)
+ self.post_process_results(test_result)
+
def generate_test_cases(self, channels, modes, traffic_types,
traffic_directions, signal_levels, chamber_mode,
positions):
@@ -619,8 +656,8 @@
}
test_cases = []
- for channel, mode, signal_level, position, traffic_type, traffic_direction in itertools.product(
- channels, modes, signal_levels, positions, traffic_types,
+ for channel, mode, signal_level, traffic_type, traffic_direction in itertools.product(
+ channels, modes, signal_levels, traffic_types,
traffic_directions):
bandwidth = int(''.join([x for x in mode if x.isdigit()]))
if channel not in allowed_configs[bandwidth]:
@@ -634,19 +671,22 @@
signal_level=signal_level,
chamber_mode=chamber_mode,
total_positions=len(positions),
- position=position)
+ positions=positions)
testcase_name = ('test_tput_stability'
- '_{}_{}_{}_ch{}_{}_pos{}'.format(
+ '_{}_{}_{}_ch{}_{}'.format(
signal_level, traffic_type, traffic_direction,
- channel, mode, position))
- setattr(self, testcase_name,
- partial(self._test_throughput_stability, testcase_params))
+ channel, mode))
+ setattr(
+ self, testcase_name,
+ partial(self._test_throughput_stability_over_orientation,
+ testcase_params))
test_cases.append(testcase_name)
return test_cases
class WifiOtaThroughputStability_TenDegree_Test(WifiOtaThroughputStabilityTest
):
+
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
@@ -655,8 +695,13 @@
['high', 'low'], 'orientation',
list(range(0, 360, 10)))
+ def setup_class(self):
+ WifiOtaThroughputStabilityTest.setup_class(self)
+ self.sniffer_subsampling = 6
+
class WifiOtaThroughputStability_45Degree_Test(WifiOtaThroughputStabilityTest):
+
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
@@ -668,6 +713,7 @@
class WifiOtaThroughputStability_SteppedStirrers_Test(
WifiOtaThroughputStabilityTest):
+
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
@@ -676,3 +722,7 @@
['high', 'low'],
'stepped stirrers',
list(range(100)))
+
+ def setup_class(self):
+ WifiOtaThroughputStabilityTest.setup_class(self)
+ self.sniffer_subsampling = 10
diff --git a/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py b/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py
index 706903c..d0a3334 100644
--- a/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py
+++ b/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py
@@ -95,8 +95,8 @@
test_types=[
'test_tx_power',
],
- country_codes=['US', 'GB', 'JP'],
- sar_states=range(0, 13))
+ country_codes=['US', 'GB', 'JP', 'CA', 'AU'],
+ sar_states=range(-1, 13))
def setup_class(self):
self.dut = self.android_devices[-1]
@@ -139,6 +139,9 @@
self.nvram_sar_data = self.read_nvram_sar_data()
self.csv_sar_data = self.read_sar_csv(self.testclass_params['sar_csv'])
+ # Configure test retries
+ self.user_params['retry_tests'] = [self.__class__.__name__]
+
def teardown_class(self):
# Turn WiFi OFF and reset AP
self.access_point.teardown()
@@ -246,11 +249,13 @@
of SAR scenarios to NVRAM data tables.
"""
- self.sar_state_mapping = collections.OrderedDict([(-1, {
+ self.sar_state_mapping = collections.OrderedDict([(-2, {
"google_name":
- 'WIFI_POWER_SCENARIO_DISABLE'
- }), (0, {
+ 'WIFI_POWER_SCENARIO_INVALID'
+ }), (-1, {
"google_name": 'WIFI_POWER_SCENARIO_DISABLE'
+ }), (0, {
+ "google_name": 'WIFI_POWER_SCENARIO_VOICE_CALL'
}), (1, {
"google_name": 'WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF'
}), (2, {
@@ -303,24 +308,24 @@
"""
sar_config = collections.OrderedDict()
- list_of_countries = ['fcc', 'jp']
+ list_of_countries = ['fcc', 'jp', 'ca']
try:
sar_config['country'] = next(country
for country in list_of_countries
- if country in sar_line)
+ if country in sar_line.split('=')[0])
except:
sar_config['country'] = 'row'
list_of_sar_states = ['grip', 'bt', 'hotspot']
try:
sar_config['state'] = next(state for state in list_of_sar_states
- if state in sar_line)
+ if state in sar_line.split('=')[0])
except:
sar_config['state'] = 'head'
list_of_bands = ['2g', '5g', '6g']
sar_config['band'] = next(band for band in list_of_bands
- if band in sar_line)
+ if band in sar_line.split('=')[0])
sar_config['rsdb'] = 'rsdb' if 'rsdb' in sar_line else 'mimo'
sar_config['airplane_mode'] = '_2=' in sar_line
@@ -328,9 +333,10 @@
sar_powers = sar_line.split('=')[1].split(',')
decoded_powers = []
for sar_power in sar_powers:
+ # Note that core 0 and 1 are flipped in the NVRAM entries
decoded_powers.append([
- (int(sar_power[2:4], 16) & int('7f', 16)) / 4,
- (int(sar_power[4:], 16) & int('7f', 16)) / 4
+ (int(sar_power[4:], 16) & int('7f', 16)) / 4,
+ (int(sar_power[2:4], 16) & int('7f', 16)) / 4
])
return tuple(sar_config.values()), decoded_powers
@@ -353,6 +359,8 @@
reg_domain = 'fcc'
elif testcase_params['country_code'] == 'JP':
reg_domain = 'jp'
+ elif testcase_params['country_code'] == 'CA':
+ reg_domain = 'ca'
else:
reg_domain = 'row'
for band, channels in self.BAND_TO_CHANNEL_MAP.items():
@@ -385,6 +393,8 @@
reg_domain = 'fcc'
elif testcase_params['country_code'] == 'JP':
reg_domain = 'jp'
+ elif testcase_params['country_code'] == 'CA':
+ reg_domain = 'ca'
else:
reg_domain = 'row'
for band, channels in self.BAND_TO_CHANNEL_MAP.items():
@@ -597,19 +607,22 @@
str) and '6g' in result['testcase_params']['channel']:
mode = 'HE' + str(result['testcase_params']['bandwidth'])
else:
- mode = 'VHT' + str(result['testcase_params']['bandwidth'])
+ mode = 'HE' + str(result['testcase_params']['bandwidth'])
regulatory_power = result['wl_curpower']['regulatory_limits'][(mode, 0,
2)]
- if result['testcase_params']['sar_state'] == 0:
- #get from wl_curpower
- csv_powers = [30, 30]
- nvram_powers = [30, 30]
- sar_config = 'SAR DISABLED'
- else:
- sar_config, nvram_powers = self.get_sar_power_from_nvram(
- result['testcase_params'])
+ board_power = result['wl_curpower']['board_limits'][(mode, str(0), 2)]
+ # try:
+ sar_config, nvram_powers = self.get_sar_power_from_nvram(
+ result['testcase_params'])
+ # except:
+ # nvram_powers = [99, 99]
+ # sar_config = 'SAR DISABLED'
+ try:
csv_config, csv_powers = self.get_sar_power_from_csv(
result['testcase_params'])
+ except:
+ #get from wl_curpower
+ csv_powers = [99, 99]
self.log.info("SAR state: {} ({})".format(
result['testcase_params']['sar_state'],
self.sar_state_mapping[result['testcase_params']['sar_state']],
@@ -618,12 +631,12 @@
result['testcase_params']['country_code']))
self.log.info('BRCM SAR Table: {}'.format(sar_config))
expected_power = [
- min([csv_powers[0], regulatory_power]) - 1.5,
- min([csv_powers[1], regulatory_power]) - 1.5
+ min([csv_powers[0], regulatory_power, board_power]) - 1.5,
+ min([csv_powers[1], regulatory_power, board_power]) - 1.5
]
- power_str = "NVRAM Powers: {}, CSV Powers: {}, Reg Powers: {}, Expected Powers: {}, Reported Powers: {}".format(
- nvram_powers, csv_powers, [regulatory_power] * 2, expected_power,
- result['tx_powers'])
+ power_str = "NVRAM Powers: {}, CSV Powers: {}, Reg Powers: {}, Board Power: {}, Expected Powers: {}, Reported Powers: {}".format(
+ nvram_powers, csv_powers, [regulatory_power] * 2,
+ [board_power] * 2, expected_power, result['tx_powers'])
max_error = max([
abs(expected_power[idx] - result['tx_powers'][idx])
for idx in [0, 1]
@@ -668,6 +681,12 @@
bw=testcase_params['bandwidth'],
duration=testcase_params['ping_duration'] *
len(testcase_params['atten_range']) + self.TEST_TIMEOUT)
+ # Set sar state
+ if testcase_params['sar_state'] == -1:
+ self.dut.adb.shell('halutil -sar disable')
+ else:
+ self.dut.adb.shell('halutil -sar enable {}'.format(
+ testcase_params['sar_state']))
# Run ping and sweep attenuation as needed
self.log.info('Starting ping.')
thread_future = wputils.get_ping_stats_nb(self.ping_server,
@@ -679,18 +698,15 @@
# Set mcs
if isinstance(testcase_params['channel'],
int) and testcase_params['channel'] < 13:
- self.dut.adb.shell('wl 2g_rate -v 0x2 -b {}'.format(
+ self.dut.adb.shell('wl 2g_rate -e 0 -s 2 -b {}'.format(
testcase_params['bandwidth']))
elif isinstance(testcase_params['channel'],
int) and testcase_params['channel'] > 13:
- self.dut.adb.shell('wl 5g_rate -v 0x2 -b {}'.format(
+ self.dut.adb.shell('wl 5g_rate -e 0 -s 2 -b {}'.format(
testcase_params['bandwidth']))
else:
self.dut.adb.shell('wl 6g_rate -e 0 -s 2 -b {}'.format(
testcase_params['bandwidth']))
- # Set sar state
- self.dut.adb.shell('halutil -sar enable {}'.format(
- testcase_params['sar_state']))
# Refresh link layer stats
llstats_obj.update_stats()
# Check sar state
@@ -703,11 +719,16 @@
last_est_out = self.dut.adb.shell(
"wl curpower | grep 'Last est. power'", ignore_status=True)
if "Last est. power" in last_est_out:
- per_chain_powers = last_est_out.split(
- ':')[1].strip().split(' ')
- per_chain_powers = [
- float(power) for power in per_chain_powers
- ]
+ try:
+ per_chain_powers = last_est_out.split(
+ ':')[1].strip().split(' ')
+ per_chain_powers = [
+ float(power) for power in per_chain_powers
+ ]
+ except:
+ per_chain_powers = [0, 0]
+ self.log.warning(
+ 'Could not parse output: {}'.format(last_est_out))
self.log.info(
'Current Tx Powers = {}'.format(per_chain_powers))
if per_chain_powers[0] > 0:
@@ -786,8 +807,11 @@
self.access_point.set_region(self.testbed_params['DFS_region'])
else:
self.access_point.set_region(self.testbed_params['default_region'])
- self.access_point.set_channel(band, testcase_params['channel'])
- self.access_point.set_bandwidth(band, testcase_params['mode'])
+ self.access_point.set_channel_and_bandwidth(band,
+ testcase_params['channel'],
+ testcase_params['mode'])
+ #self.access_point.set_channel(band, testcase_params['channel'])
+ #self.access_point.set_bandwidth(band, testcase_params['mode'])
if 'low' in testcase_params['ap_power']:
self.log.info('Setting low AP power.')
self.access_point.set_power(
@@ -825,9 +849,17 @@
if self.testbed_params.get('txbf_off', False):
wputils.disable_beamforming(self.dut)
wutils.set_wifi_country_code(self.dut, testcase_params['country_code'])
+ current_country = self.dut.adb.shell('wl country')
+ self.log.info('Current country code: {}'.format(current_country))
+ if testcase_params['country_code'] not in current_country:
+ asserts.fail('Country code not correct.')
+ chan_list = self.dut.adb.shell('wl chan_info_list')
+ if str(testcase_params['channel']) not in chan_list:
+ asserts.skip('Channel {} not supported in {}'.format(
+ testcase_params['channel'], testcase_params['country_code']))
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
- num_of_tries=1,
+ num_of_tries=5,
check_connectivity=True)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
@@ -925,3 +957,23 @@
partial(self._test_ping, testcase_params))
test_cases.append(testcase_name)
return test_cases
+
+
+class WifiTxPowerCheck_BasicSAR_Test(WifiTxPowerCheckTest):
+
+ def __init__(self, controllers):
+ base_test.BaseTestClass.__init__(self, controllers)
+ self.testcase_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_case())
+ self.testclass_metric_logger = (
+ BlackboxMappedMetricLogger.for_test_class())
+ self.publish_testcase_metrics = True
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[6, 36, 52, 100, 149, '6g37'],
+ modes=['bw20', 'bw160'],
+ test_types=[
+ 'test_tx_power',
+ ],
+ country_codes=['US', 'GB', 'JP', 'CA'],
+ sar_states=[-1, 0, 1, 2, 3, 4])
diff --git a/acts_tests/tests/google/wifi/aware/functional/AttachTest.py b/acts_tests/tests/google/wifi/aware/functional/AttachTest.py
index eee0f9d..8b16dc7 100644
--- a/acts_tests/tests/google/wifi/aware/functional/AttachTest.py
+++ b/acts_tests/tests/google/wifi/aware/functional/AttachTest.py
@@ -166,3 +166,18 @@
# try enabling Aware again (attach)
dut.droid.wifiAwareAttach()
autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ @test_tracker_info(uuid="")
+ def test_attach_detach_attach_again(self):
+ """Validated there is no delay between Disable Aware and re-enable Aware
+ """
+ dut = self.android_devices[0]
+
+ # enable Aware (attach)
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ dut.droid.wifiAwareDestroyAll()
+ # Restart Aware immediately
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED, timeout=1)
diff --git a/acts_tests/tests/google/wifi/aware/functional/DiscoveryTest.py b/acts_tests/tests/google/wifi/aware/functional/DiscoveryTest.py
index 39f009d..69dc42c 100644
--- a/acts_tests/tests/google/wifi/aware/functional/DiscoveryTest.py
+++ b/acts_tests/tests/google/wifi/aware/functional/DiscoveryTest.py
@@ -14,6 +14,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import queue
import string
import time
@@ -32,6 +33,7 @@
PAYLOAD_SIZE_MIN = 0
PAYLOAD_SIZE_TYPICAL = 1
PAYLOAD_SIZE_MAX = 2
+ EVENT_TIMEOUT = 3
# message strings
query_msg = "How are you doing? 你好嗎？"
@@ -1111,6 +1113,18 @@
event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], s_to_p_msg,
"Message on service %s from Subscriber to Publisher "
"not received correctly" % session_name["pub"][p_disc_id])
+ try:
+ event = p_dut.ed.pop_event(autils.decorate_event(aconsts.SESSION_CB_ON_MESSAGE_RECEIVED,
+ p_disc_id), self.EVENT_TIMEOUT)
+ p_dut.log.info("re-transmit message received: "
+ + event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING])
+ asserts.assert_equal(
+ event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], s_to_p_msg,
+ "Message on service %s from Subscriber to Publisher "
+ "not received correctly" % session_name["pub"][p_disc_id])
+ except queue.Empty:
+ p_dut.log.info("no re-transmit message")
+
peer_id_on_pub = event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
# Message send from Publisher to Subscriber
@@ -1129,6 +1143,17 @@
event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], p_to_s_msg,
"Message on service %s from Publisher to Subscriber"
"not received correctly" % session_name["sub"][s_disc_id])
+ try:
+ event = s_dut.ed.pop_event(autils.decorate_event(aconsts.SESSION_CB_ON_MESSAGE_RECEIVED,
+ s_disc_id), self.EVENT_TIMEOUT)
+ s_dut.log.info("re-transmit message received: "
+ + event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING])
+ asserts.assert_equal(
+ event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], p_to_s_msg,
+ "Message on service %s from Publisher to Subscriber"
+ "not received correctly" % session_name["sub"][s_disc_id])
+ except queue.Empty:
+ s_dut.log.info("no re-transmit message")
def run_multiple_concurrent_services_same_name_diff_ssi(self, type_x, type_y):
"""Validate same service name with multiple service specific info on publisher
diff --git a/acts_tests/tests/google/wifi/aware/performance/LatencyTest.py b/acts_tests/tests/google/wifi/aware/performance/LatencyTest.py
index 871602b..9c44ca6 100644
--- a/acts_tests/tests/google/wifi/aware/performance/LatencyTest.py
+++ b/acts_tests/tests/google/wifi/aware/performance/LatencyTest.py
@@ -33,7 +33,7 @@
# take some time
WAIT_FOR_CLUSTER = 5
- def start_discovery_session(self, dut, session_id, is_publish, dtype):
+ def start_discovery_session(self, dut, session_id, is_publish, dtype, instant_mode = None):
"""Start a discovery session
Args:
@@ -41,6 +41,7 @@
session_id: ID of the Aware session in which to start discovery
is_publish: True for a publish session, False for subscribe session
dtype: Type of the discovery session
+ instant_mode: set the channel to use instant communication mode.
Returns:
Discovery session started event.
@@ -48,6 +49,9 @@
config = {}
config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "GoogleTestServiceXY"
+ if instant_mode is not None:
+ config[aconsts.DISCOVERY_KEY_INSTANT_COMMUNICATION_MODE] = instant_mode
+
if is_publish:
disc_id = dut.droid.wifiAwarePublish(session_id, config)
@@ -74,6 +78,7 @@
solicited/active.
dw_24ghz: DW interval in the 2.4GHz band.
dw_5ghz: DW interval in the 5GHz band.
+ num_iterations: number of the iterations.
startup_offset: The start-up gap (in seconds) between the two devices
timeout_period: Time period over which to measure synchronization
"""
@@ -160,6 +165,7 @@
solicited/active.
dw_24ghz: DW interval in the 2.4GHz band.
dw_5ghz: DW interval in the 5GHz band.
+ num_iterations: number of the iterations.
"""
key = "%s_dw24_%d_dw5_%d" % ("unsolicited_passive"
if do_unsolicited_passive else
@@ -237,13 +243,15 @@
p_dut.droid.wifiAwareDestroyAll()
s_dut.droid.wifiAwareDestroyAll()
- def run_message_latency(self, results, dw_24ghz, dw_5ghz, num_iterations):
+ def run_message_latency(self, results, dw_24ghz, dw_5ghz, num_iterations, instant_mode=None):
"""Run the message tx latency test with the specified DW intervals.
Args:
results: Result array to be populated - will add results (not erase it)
dw_24ghz: DW interval in the 2.4GHz band.
dw_5ghz: DW interval in the 5GHz band.
+ num_iterations: number of the iterations.
+ instant_mode: set the band to use instant communication mode, 2G or 5G
"""
key = "dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
results[key] = {}
@@ -262,9 +270,9 @@
p_dut,
s_dut,
p_config=autils.create_discovery_config(
- self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED),
+ self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED, instant_mode=instant_mode),
s_config=autils.create_discovery_config(
- self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_PASSIVE),
+ self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_PASSIVE, instant_mode=instant_mode),
device_startup_offset=self.device_startup_offset)
latencies = []
@@ -330,6 +338,7 @@
results: Result array to be populated - will add results (not erase it)
dw_24ghz: DW interval in the 2.4GHz band.
dw_5ghz: DW interval in the 5GHz band.
+ num_iterations: number of the iterations.
"""
key_avail = "on_avail_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
key_link_props = "link_props_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
@@ -435,21 +444,21 @@
results[key_avail]["ndp_setup_failures"] = ndp_setup_failures
def run_end_to_end_latency(self, results, dw_24ghz, dw_5ghz,
- num_iterations, startup_offset, include_setup):
+ num_iterations, startup_offset, include_setup, instant_mode = None):
"""Measure the latency for end-to-end communication link setup:
- Start Aware
- Discovery
- - Message from Sub -> Pub
- - Message from Pub -> Sub
- NDP setup
Args:
results: Result array to be populated - will add results (not erase it)
dw_24ghz: DW interval in the 2.4GHz band.
dw_5ghz: DW interval in the 5GHz band.
+ num_iterations: number of the iterations.
startup_offset: The start-up gap (in seconds) between the two devices
include_setup: True to include the cluster setup in the latency
measurements.
+ instant_mode: set the band to use instant communication mode, 2G or 5G
"""
key = "dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
results[key] = {}
@@ -492,11 +501,19 @@
# start publish
p_disc_id, p_disc_event = self.start_discovery_session(
- p_dut, p_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED)
+ p_dut, p_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED, instant_mode)
# start subscribe
s_disc_id, s_session_event = self.start_discovery_session(
- s_dut, s_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE)
+ s_dut, s_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE, instant_mode)
+
+ # create NDP
+
+ # Publisher: request network
+ p_req_key = autils.request_network(
+ p_dut,
+ p_dut.droid.wifiAwareCreateNetworkSpecifier(
+ p_disc_id, None, None))
# wait for discovery (allow for failures here since running lots of
# samples and would like to get the partial data even in the presence of
@@ -516,82 +533,6 @@
failures = failures + 1
break
- # message from Sub -> Pub
- msg_s2p = "Message Subscriber -> Publisher #%d" % i
- next_msg_id = self.get_next_msg_id()
- s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub,
- next_msg_id, msg_s2p, 0)
-
- # wait for Tx confirmation
- try:
- s_dut.ed.pop_event(aconsts.SESSION_CB_ON_MESSAGE_SENT,
- autils.EVENT_TIMEOUT)
- except queue.Empty:
- s_dut.log.info("[Subscriber] Timed out while waiting for "
- "SESSION_CB_ON_MESSAGE_SENT")
- failures = failures + 1
- break
-
- # wait for Rx confirmation (and validate contents)
- try:
- event = p_dut.ed.pop_event(
- aconsts.SESSION_CB_ON_MESSAGE_RECEIVED,
- autils.EVENT_TIMEOUT)
- peer_id_on_pub = event['data'][
- aconsts.SESSION_CB_KEY_PEER_ID]
- if (event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING]
- != msg_s2p):
- p_dut.log.info(
- "[Publisher] Corrupted input message - %s", event)
- failures = failures + 1
- break
- except queue.Empty:
- p_dut.log.info("[Publisher] Timed out while waiting for "
- "SESSION_CB_ON_MESSAGE_RECEIVED")
- failures = failures + 1
- break
-
- # message from Pub -> Sub
- msg_p2s = "Message Publisher -> Subscriber #%d" % i
- next_msg_id = self.get_next_msg_id()
- p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub,
- next_msg_id, msg_p2s, 0)
-
- # wait for Tx confirmation
- try:
- p_dut.ed.pop_event(aconsts.SESSION_CB_ON_MESSAGE_SENT,
- autils.EVENT_TIMEOUT)
- except queue.Empty:
- p_dut.log.info("[Publisher] Timed out while waiting for "
- "SESSION_CB_ON_MESSAGE_SENT")
- failures = failures + 1
- break
-
- # wait for Rx confirmation (and validate contents)
- try:
- event = s_dut.ed.pop_event(
- aconsts.SESSION_CB_ON_MESSAGE_RECEIVED,
- autils.EVENT_TIMEOUT)
- if (event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING]
- != msg_p2s):
- s_dut.log.info(
- "[Subscriber] Corrupted input message - %s", event)
- failures = failures + 1
- break
- except queue.Empty:
- s_dut.log.info("[Subscriber] Timed out while waiting for "
- "SESSION_CB_ON_MESSAGE_RECEIVED")
- failures = failures + 1
- break
-
- # create NDP
-
- # Publisher: request network
- p_req_key = autils.request_network(
- p_dut,
- p_dut.droid.wifiAwareCreateNetworkSpecifier(
- p_disc_id, peer_id_on_pub, None))
-
# Subscriber: request network
s_req_key = autils.request_network(
s_dut,
@@ -613,6 +554,8 @@
cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
(cconsts.NETWORK_CB_KEY_ID, s_req_key))
except:
+ s_dut.log.info("[Subscriber] Timed out while waiting for "
+ "EVENT_NETWORK_CALLBACK")
failures = failures + 1
break
@@ -742,6 +685,34 @@
asserts.explicit_pass(
"test_message_latency_default_dws finished", extras=results)
+ def test_message_latency_default_dws_instant_mode_2g(self):
+ """Measure the send message latency with the default DW configuration. Test
+ performed on non-queued message transmission - i.e. waiting for confirmation
+ of reception (ACK) before sending the next message."""
+ results = {}
+ self.run_message_latency(
+ results=results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=100,
+ instant_mode="2G")
+ asserts.explicit_pass(
+ "test_message_latency_default_dws finished", extras=results)
+
+ def test_message_latency_default_dws_instant_mode_5g(self):
+ """Measure the send message latency with the default DW configuration. Test
+ performed on non-queued message transmission - i.e. waiting for confirmation
+ of reception (ACK) before sending the next message."""
+ results = {}
+ self.run_message_latency(
+ results=results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=100,
+ instant_mode="5G")
+ asserts.explicit_pass(
+ "test_message_latency_default_dws finished", extras=results)
+
def test_message_latency_non_interactive_dws(self):
"""Measure the send message latency with the DW configuration for
non-interactive mode. Test performed on non-queued message transmission -
@@ -787,8 +758,6 @@
"""Measure the latency for end-to-end communication link setup:
- Start Aware
- Discovery
- - Message from Sub -> Pub
- - Message from Pub -> Sub
- NDP setup
"""
results = {}
@@ -802,14 +771,48 @@
asserts.explicit_pass(
"test_end_to_end_latency_default_dws finished", extras=results)
+ def test_end_to_end_latency_default_dws_instant_mode_2g(self):
+ """Measure the latency for end-to-end communication link setup:
+ - Start Aware
+ - Discovery
+ - NDP setup
+ """
+ results = {}
+ self.run_end_to_end_latency(
+ results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=0,
+ include_setup=True,
+ instant_mode="2G")
+ asserts.explicit_pass(
+ "test_end_to_end_latency_default_dws finished", extras=results)
+
+ def test_end_to_end_latency_default_dws_instant_mode_5g(self):
+ """Measure the latency for end-to-end communication link setup:
+ - Start Aware
+ - Discovery
+ - NDP setup
+ """
+ results = {}
+ self.run_end_to_end_latency(
+ results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=0,
+ include_setup=True,
+ instant_mode="5G")
+ asserts.explicit_pass(
+ "test_end_to_end_latency_default_dws finished", extras=results)
+
def test_end_to_end_latency_post_attach_default_dws(self):
"""Measure the latency for end-to-end communication link setup without
the initial synchronization:
- Start Aware & synchronize initially
- Loop:
- Discovery
- - Message from Sub -> Pub
- - Message from Pub -> Sub
- NDP setup
"""
results = {}
@@ -823,3 +826,59 @@
asserts.explicit_pass(
"test_end_to_end_latency_post_attach_default_dws finished",
extras=results)
+
+ def test_end_to_end_latency_post_attach_default_dws_instant_mode_2g(self):
+ """Measure the latency for end-to-end communication link setup without
+ the initial synchronization:
+ - Start Aware & synchronize initially
+ - Loop:
+ - Discovery
+ - NDP setup
+ """
+ asserts.skip_if(not self.android_devices[0].droid.isSdkAtLeastT(),
+ "instant communication mode is only supported on T+")
+ asserts.skip_if(not (self.android_devices[0].aware_capabilities[aconsts
+ .CAP_SUPPORTED_INSTANT_COMMUNICATION_MODE]
+ and self.android_devices[0].aware_capabilities[aconsts
+ .CAP_SUPPORTED_INSTANT_COMMUNICATION_MODE]),
+ "Device doesn't support instant communication mode")
+ results = {}
+ self.run_end_to_end_latency(
+ results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=0,
+ include_setup=False,
+ instant_mode="2G")
+ asserts.explicit_pass(
+ "test_end_to_end_latency_post_attach_default_dws_instant_mode finished",
+ extras=results)
+
+ def test_end_to_end_latency_post_attach_default_dws_instant_mode_5g(self):
+ """Measure the latency for end-to-end communication link setup without
+ the initial synchronization:
+ - Start Aware & synchronize initially
+ - Loop:
+ - Discovery
+ - NDP setup
+ """
+ asserts.skip_if(not self.android_devices[0].droid.isSdkAtLeastT(),
+ "instant communication mode is only supported on T+")
+ asserts.skip_if(not (self.android_devices[0].aware_capabilities[aconsts
+ .CAP_SUPPORTED_INSTANT_COMMUNICATION_MODE]
+ and self.android_devices[0].aware_capabilities[aconsts
+ .CAP_SUPPORTED_INSTANT_COMMUNICATION_MODE]),
+ "Device doesn't support instant communication mode")
+ results = {}
+ self.run_end_to_end_latency(
+ results,
+ dw_24ghz=aconsts.POWER_DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.POWER_DW_5_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=0,
+ include_setup=False,
+ instant_mode="5G")
+ asserts.explicit_pass(
+ "test_end_to_end_latency_post_attach_default_dws_instant_mode finished",
+ extras=results)
diff --git a/acts_tests/tests/google/wifi/rtt/functional/RangeAwareTest.py b/acts_tests/tests/google/wifi/rtt/functional/RangeAwareTest.py
index 1051fc4..84ad88e 100644
--- a/acts_tests/tests/google/wifi/rtt/functional/RangeAwareTest.py
+++ b/acts_tests/tests/google/wifi/rtt/functional/RangeAwareTest.py
@@ -339,19 +339,6 @@
#############################################################################
- @test_tracker_info(uuid="9e4e7ab4-2254-498c-9788-21e15ed9a370")
- def test_rtt_oob_discovery_one_way(self):
- """Perform RTT between 2 Wi-Fi Aware devices. Use out-of-band discovery
- to communicate the MAC addresses to the peer. Test one-direction RTT only.
- Functionality test: Only evaluate success rate.
- """
- rtt_results = self.run_rtt_oob_discovery_set(
- do_both_directions=False,
- iter_count=self.NUM_ITER,
- time_between_iterations=self.TIME_BETWEEN_ITERATIONS,
- time_between_roles=self.TIME_BETWEEN_ROLES)
- self.verify_results(rtt_results)
-
@test_tracker_info(uuid="22edba77-eeb2-43ee-875a-84437550ad84")
def test_rtt_oob_discovery_both_ways(self):
"""Perform RTT between 2 Wi-Fi Aware devices. Use out-of-band discovery
@@ -393,19 +380,6 @@
time_between_roles=self.TIME_BETWEEN_ROLES)
self.verify_results(rtt_results1, rtt_results2)
- @test_tracker_info(uuid="3a1d19a2-7241-49e0-aaf2-0a1da4c29783")
- def test_rtt_oob_discovery_one_way_with_accuracy_evaluation(self):
- """Perform RTT between 2 Wi-Fi Aware devices. Use out-of-band discovery
- to communicate the MAC addresses to the peer. Test one-direction RTT only.
- Performance test: evaluate success rate and accuracy.
- """
- rtt_results = self.run_rtt_oob_discovery_set(
- do_both_directions=False,
- iter_count=self.NUM_ITER,
- time_between_iterations=self.TIME_BETWEEN_ITERATIONS,
- time_between_roles=self.TIME_BETWEEN_ROLES)
- self.verify_results(rtt_results, accuracy_evaluation=True)
-
@test_tracker_info(uuid="82f954a5-c0ec-4bc6-8940-3b72199328ac")
def test_rtt_oob_discovery_both_ways_with_accuracy_evaluation(self):
"""Perform RTT between 2 Wi-Fi Aware devices. Use out-of-band discovery
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiEnterprise11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiEnterprise11axTest.py
index 7f0f121..94313b2 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiEnterprise11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiEnterprise11axTest.py
@@ -15,7 +15,7 @@
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiEnterpriseTest import WifiEnterpriseTest
+from ..WifiEnterpriseTest import WifiEnterpriseTest
WifiEnums = wutils.WifiEnums
# EAP Macros
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiEnterpriseRoaming11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiEnterpriseRoaming11axTest.py
index ec70da9..781e5af 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiEnterpriseRoaming11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiEnterpriseRoaming11axTest.py
@@ -15,7 +15,7 @@
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiEnterpriseRoamingTest import WifiEnterpriseRoamingTest
+from ..WifiEnterpriseRoamingTest import WifiEnterpriseRoamingTest
WifiEnums = wutils.WifiEnums
# EAP Macros
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiManager11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiManager11axTest.py
index d2fb981..fd906a0 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiManager11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiManager11axTest.py
@@ -14,7 +14,7 @@
# limitations under the License.
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiManagerTest import WifiManagerTest
+from ..WifiManagerTest import WifiManagerTest
class WifiManager11axTest(WifiManagerTest):
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiNetworkSuggestion11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiNetworkSuggestion11axTest.py
index 2c45e8c..ab08cce 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiNetworkSuggestion11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiNetworkSuggestion11axTest.py
@@ -15,7 +15,7 @@
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiNetworkSuggestionTest import WifiNetworkSuggestionTest
+from ..WifiNetworkSuggestionTest import WifiNetworkSuggestionTest
WifiEnums = wutils.WifiEnums
# EAP Macros
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiPno11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiPno11axTest.py
index 7509d28..63b43ef 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiPno11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiPno11axTest.py
@@ -15,7 +15,7 @@
import time
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiPnoTest import WifiPnoTest
+from ..WifiPnoTest import WifiPnoTest
MAX_ATTN = 95
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiSoftApAcs11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiSoftApAcs11axTest.py
index 0155be4..1a4a2c8 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiSoftApAcs11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiSoftApAcs11axTest.py
@@ -17,7 +17,7 @@
from acts.controllers.ap_lib import hostapd_constants
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiSoftApAcsTest import WifiSoftApAcsTest
+from ..WifiSoftApAcsTest import WifiSoftApAcsTest
class WifiSoftApAcs11axTest(WifiSoftApAcsTest):
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiStaApConcurrency11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiStaApConcurrency11axTest.py
index bdb9dc1..88b1e90 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiStaApConcurrency11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiStaApConcurrency11axTest.py
@@ -17,7 +17,7 @@
import acts.signals as signals
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiStaApConcurrencyTest import WifiStaApConcurrencyTest
+from ..WifiStaApConcurrencyTest import WifiStaApConcurrencyTest
class WifiStaApConcurrency11axTest(WifiStaApConcurrencyTest):
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiStaConcurrencyNetworkRequest11axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiStaConcurrencyNetworkRequest11axTest.py
index 215a6e6..8dd76627b 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiStaConcurrencyNetworkRequest11axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiStaConcurrencyNetworkRequest11axTest.py
@@ -16,7 +16,7 @@
import acts.utils as utils
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiStaConcurrencyNetworkRequestTest import WifiStaConcurrencyNetworkRequestTest
+from ..WifiStaConcurrencyNetworkRequestTest import WifiStaConcurrencyNetworkRequestTest
class WifiStaConcurrencyNetworkRequest11axTest(
diff --git a/acts_tests/tests/google/wifi/wifi6/WifiWpa311axTest.py b/acts_tests/tests/google/wifi/wifi6/WifiWpa311axTest.py
index 57ab366..cfe7987 100644
--- a/acts_tests/tests/google/wifi/wifi6/WifiWpa311axTest.py
+++ b/acts_tests/tests/google/wifi/wifi6/WifiWpa311axTest.py
@@ -14,7 +14,7 @@
# limitations under the License.
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiWpa3OweTest import WifiWpa3OweTest
+from ..WifiWpa3OweTest import WifiWpa3OweTest
class WifiWpa311axTest(WifiWpa3OweTest):
diff --git a/acts_tests/tests/google/wifi/wifi6e/WifiNetworkSelector6eTest.py b/acts_tests/tests/google/wifi/wifi6e/WifiNetworkSelector6eTest.py
index 4a0ecf3..fa51247 100644
--- a/acts_tests/tests/google/wifi/wifi6e/WifiNetworkSelector6eTest.py
+++ b/acts_tests/tests/google/wifi/wifi6e/WifiNetworkSelector6eTest.py
@@ -17,7 +17,7 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiNetworkSelectorTest import WifiNetworkSelectorTest
+from ..WifiNetworkSelectorTest import WifiNetworkSelectorTest
# WifiNetworkSelector imposes a 10 seconds gap between two selections
NETWORK_SELECTION_TIME_GAP = 12
diff --git a/acts_tests/tests/google/wifi/wifi6e/WifiPno6eTest.py b/acts_tests/tests/google/wifi/wifi6e/WifiPno6eTest.py
index 0bfc3da..fbccc88 100644
--- a/acts_tests/tests/google/wifi/wifi6e/WifiPno6eTest.py
+++ b/acts_tests/tests/google/wifi/wifi6e/WifiPno6eTest.py
@@ -17,7 +17,7 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiPnoTest import WifiPnoTest
+from ..WifiPnoTest import WifiPnoTest
MAX_ATTN = 95
diff --git a/acts_tests/tests/google/wifi/wifi6e/WifiStaApConcurrency6eTest.py b/acts_tests/tests/google/wifi/wifi6e/WifiStaApConcurrency6eTest.py
index 15a3264..5ba6dec 100644
--- a/acts_tests/tests/google/wifi/wifi6e/WifiStaApConcurrency6eTest.py
+++ b/acts_tests/tests/google/wifi/wifi6e/WifiStaApConcurrency6eTest.py
@@ -18,7 +18,7 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from WifiStaApConcurrencyTest import WifiStaApConcurrencyTest
+from ..WifiStaApConcurrencyTest import WifiStaApConcurrencyTest
WifiEnums = wutils.WifiEnums
WIFI_CONFIG_SOFTAP_BAND_2G = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G
diff --git a/acts_tests/tests/google/wifi/wifi6e/WifiTeleCoex6eTest.py b/acts_tests/tests/google/wifi/wifi6e/WifiTeleCoex6eTest.py
index 066abdd..9a35f4e 100644
--- a/acts_tests/tests/google/wifi/wifi6e/WifiTeleCoex6eTest.py
+++ b/acts_tests/tests/google/wifi/wifi6e/WifiTeleCoex6eTest.py
@@ -16,7 +16,7 @@
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
-from WifiTeleCoexTest import WifiTeleCoexTest
+from ..WifiTeleCoexTest import WifiTeleCoexTest
class WifiTeleCoex6eTest(WifiTeleCoexTest):
