Catch StopIteration to comply with PEP 479 am: 61e2c1086a am: d6873adde4 am: e416085a0e
Original change: https://android-review.googlesource.com/c/platform/tools/test/connectivity/+/2015655
Change-Id: I22ac785d0d7caabc1bf14ef9ef52580213ababba
diff --git a/acts/framework/acts/controllers/attenuator_lib/_tnhelper.py b/acts/framework/acts/controllers/attenuator_lib/_tnhelper.py
index 348cab1..b7e0f8f 100644
--- a/acts/framework/acts/controllers/attenuator_lib/_tnhelper.py
+++ b/acts/framework/acts/controllers/attenuator_lib/_tnhelper.py
@@ -79,7 +79,7 @@
"""
logging.debug('Diagnosing telnet connection')
try:
- job_result = job.run('ping {} -c 5 -i 0.1'.format(
+ job_result = job.run('ping {} -c 5 -i 0.2'.format(
self._ip_address))
except:
logging.error("Unable to ping telnet server.")
diff --git a/acts/framework/acts/controllers/attenuator_lib/minicircuits/http.py b/acts/framework/acts/controllers/attenuator_lib/minicircuits/http.py
index acde271..95fa0ba 100644
--- a/acts/framework/acts/controllers/attenuator_lib/minicircuits/http.py
+++ b/acts/framework/acts/controllers/attenuator_lib/minicircuits/http.py
@@ -35,7 +35,6 @@
With the exception of HTTP-specific commands, all functionality is defined
by the AttenuatorInstrument class.
"""
-
def __init__(self, num_atten=1):
super(AttenuatorInstrument, self).__init__(num_atten)
self._ip_address = None
@@ -86,7 +85,7 @@
"""
pass
- def set_atten(self, idx, value, strict=True, **_):
+ def set_atten(self, idx, value, strict=True, retry=False, **_):
"""This function sets the attenuation of an attenuator given its index
in the instrument.
@@ -98,6 +97,7 @@
strict: if True, function raises an error when given out of
bounds attenuation values, if false, the function sets out of
bounds values to 0 or max_atten.
+ retry: if True, command will be retried if possible
Raises:
InvalidDataError if the attenuator does not respond with the
@@ -112,20 +112,25 @@
value)
# The actual device uses one-based index for channel numbers.
att_req = urllib.request.urlopen(
- 'http://{}:{}/CHAN:{}:SETATT:{}'.format(
- self._ip_address, self._port, idx + 1, value),
+ 'http://{}:{}/CHAN:{}:SETATT:{}'.format(self._ip_address,
+ self._port, idx + 1,
+ value),
timeout=self._timeout)
- att_resp = att_req.read().decode('utf-8')
+ att_resp = att_req.read().decode('utf-8').strip()
if att_resp != '1':
- raise attenuator.InvalidDataError(
- 'Attenuator returned invalid data. Attenuator returned: {}'.
- format(att_resp))
+ if retry:
+ self.set_atten(idx, value, strict, retry=False)
+ else:
+ raise attenuator.InvalidDataError(
+ 'Attenuator returned invalid data. Attenuator returned: {}'
+ .format(att_resp))
- def get_atten(self, idx, **_):
+ def get_atten(self, idx, retry=False, **_):
"""Returns the current attenuation of the attenuator at the given index.
Args:
idx: The index of the attenuator.
+ retry: if True, command will be retried if possible
Raises:
InvalidDataError if the attenuator does not respond with the
@@ -137,15 +142,17 @@
if not (0 <= idx < self.num_atten):
raise IndexError('Attenuator index out of range!', self.num_atten,
idx)
- att_req = urllib.request.urlopen(
- 'http://{}:{}/CHAN:{}:ATT?'.format(self._ip_address, self.port,
- idx + 1),
- timeout=self._timeout)
+ att_req = urllib.request.urlopen('http://{}:{}/CHAN:{}:ATT?'.format(
+ self._ip_address, self.port, idx + 1),
+ timeout=self._timeout)
att_resp = att_req.read().decode('utf-8')
try:
atten_val = float(att_resp)
except:
- raise attenuator.InvalidDataError(
- 'Attenuator returned invalid data. Attenuator returned: {}'.
- format(att_resp))
+ if retry:
+ self.get_atten(idx, retry=False)
+ else:
+ raise attenuator.InvalidDataError(
+ 'Attenuator returned invalid data. Attenuator returned: {}'
+ .format(att_resp))
return atten_val
diff --git a/acts/framework/acts/controllers/bits.py b/acts/framework/acts/controllers/bits.py
index 5194f92..d89a9b3 100644
--- a/acts/framework/acts/controllers/bits.py
+++ b/acts/framework/acts/controllers/bits.py
@@ -1,9 +1,9 @@
"""Module managing the required definitions for using the bits power monitor"""
-from datetime import datetime
import logging
import os
import time
+import uuid
from acts import context
from acts.controllers import power_metrics
@@ -29,6 +29,32 @@
return [bits.config for bits in bitses]
+class BitsError(Exception):
+ pass
+
+
+class _BitsCollection(object):
+ """Object that represents a bits collection
+
+ Attributes:
+ name: The name given to the collection.
+ markers_buffer: An array of un-flushed markers, each marker is
+ represented by a bi-dimensional tuple with the format
+ (<nanoseconds_since_epoch or datetime>, <text>).
+ monsoon_output_path: A path to store monsoon-like data if possible, Bits
+ uses this path to attempt data extraction in monsoon format, if this
+ parameter is left as None such extraction is not attempted.
+ """
+
+ def __init__(self, name, monsoon_output_path=None):
+ self.monsoon_output_path = monsoon_output_path
+ self.name = name
+ self.markers_buffer = []
+
+ def add_marker(self, timestamp, marker_text):
+ self.markers_buffer.append((timestamp, marker_text))
+
+
def _transform_name(bits_metric_name):
"""Transform bits metrics names to a more succinct version.
@@ -62,7 +88,7 @@
elif 'mV' == unit:
suffix = 'avg_voltage'
else:
- logging.getLogger().warning('unknown unit type for unit %s' % unit)
+ logging.warning('unknown unit type for unit %s' % unit)
suffix = ''
if 'Monsoon' == rail:
@@ -87,7 +113,7 @@
elif 'mV' == unit:
unit_type = 'voltage'
else:
- logging.getLogger().warning('unknown unit type for unit %s' % unit)
+ logging.warning('unknown unit type for unit %s' % unit)
continue
name = _transform_name(sample['name'])
@@ -111,6 +137,10 @@
class Bits(object):
+
+ ROOT_RAIL_KEY = 'RootRail'
+ ROOT_RAIL_DEFAULT_VALUE = 'Monsoon:mA'
+
def __init__(self, index, config):
"""Creates an instance of a bits controller.
@@ -139,17 +169,26 @@
'serial': 'serial_2'
}
]
+ // optional
+ 'RootRail': 'Monsoon:mA'
}
"""
self.index = index
self.config = config
self._service = None
self._client = None
+ self._active_collection = None
+ self._collections_counter = 0
+ self._root_rail = config.get(self.ROOT_RAIL_KEY,
+ self.ROOT_RAIL_DEFAULT_VALUE)
def setup(self, *_, registry=None, **__):
"""Starts a bits_service in the background.
- This function needs to be
+ This function needs to be called with either a registry or after calling
+ power_monitor.update_registry, and it needs to be called before any other
+ method in this class.
+
Args:
registry: A dictionary with files used by bits. Format:
{
@@ -208,6 +247,8 @@
'bits_service_out_%s.txt' % self.index)
service_name = 'bits_config_%s' % self.index
+ self._active_collection = None
+ self._collections_counter = 0
self._service = bits_service.BitsService(config,
bits_service_binary,
output_log,
@@ -219,7 +260,7 @@
config)
# this call makes sure that the client can interact with the server.
devices = self._client.list_devices()
- logging.getLogger().debug(devices)
+ logging.debug(devices)
def disconnect_usb(self, *_, **__):
self._client.disconnect_usb()
@@ -227,16 +268,29 @@
def connect_usb(self, *_, **__):
self._client.connect_usb()
- def measure(self, *_, measurement_args=None, **__):
+ def measure(self, *_, measurement_args=None,
+ measurement_name=None, monsoon_output_path=None,
+ **__):
"""Blocking function that measures power through bits for the specified
duration. Results need to be consulted through other methods such as
- get_metrics or export_to_csv.
+ get_metrics or post processing files like the ones
+ generated at monsoon_output_path after calling `release_resources`.
Args:
measurement_args: A dictionary with the following structure:
{
'duration': <seconds to measure for>
+ 'hz': <samples per second>
+ 'measure_after_seconds': <sleep time before measurement>
}
+ The actual number of samples per second is limited by the
+ bits configuration. The value of hz is defaulted to 1000.
+ measurement_name: A name to give to the measurement (which is also
+ used as the Bits collection name. Bits collection names (and
+ therefore measurement names) need to be unique within the
+ context of a Bits object.
+ monsoon_output_path: If provided this path will be used to generate
+ a monsoon like formatted file at the release_resources step.
"""
if measurement_args is None:
raise ValueError('measurement_args can not be left undefined')
@@ -245,12 +299,41 @@
if duration is None:
raise ValueError(
'duration can not be left undefined within measurement_args')
- self._client.start_collection()
+
+ hz = measurement_args.get('hz', 1000)
+
+ # Delay the start of the measurement if an offset is required
+ measure_after_seconds = measurement_args.get('measure_after_seconds')
+ if measure_after_seconds:
+ time.sleep(measure_after_seconds)
+
+ if self._active_collection:
+ raise BitsError(
+ 'Attempted to start a collection while there is still an '
+ 'active one. Active collection: %s',
+ self._active_collection.name)
+
+ self._collections_counter = self._collections_counter + 1
+ # The name gets a random 8 characters salt suffix because the Bits
+ # client has a bug where files with the same name are considered to be
+ # the same collection and it won't load two files with the same name.
+ # b/153170987 b/153944171
+ if not measurement_name:
+ measurement_name = 'bits_collection_%s_%s' % (
+ str(self._collections_counter), str(uuid.uuid4())[0:8])
+
+ self._active_collection = _BitsCollection(measurement_name,
+ monsoon_output_path)
+ self._client.start_collection(self._active_collection.name,
+ default_sampling_rate=hz)
time.sleep(duration)
def get_metrics(self, *_, timestamps=None, **__):
"""Gets metrics for the segments delimited by the timestamps dictionary.
+ Must be called before releasing resources, otherwise it will fail adding
+ markers to the collection.
+
Args:
timestamps: A dictionary of the shape:
{
@@ -276,6 +359,9 @@
metrics = {}
for segment_name, times in timestamps.items():
+ if 'start' not in times or 'end' not in times:
+ continue
+
start = times['start']
end = times['end']
@@ -285,18 +371,96 @@
# The preferred way for new calls to this function should be using
# datetime instead which is unambiguous
if isinstance(start, (int, float)):
- start = times['start'] * 1e6
+ start = start * 1e6
if isinstance(end, (int, float)):
- end = times['end'] * 1e6
+ end = end * 1e6
- self._client.add_marker(start, 'start - %s' % segment_name)
- self._client.add_marker(end, 'end - %s' % segment_name)
- raw_metrics = self._client.get_metrics(start, end)
+ raw_metrics = self._client.get_metrics(self._active_collection.name,
+ start=start, end=end)
+ self._add_marker(start, 'start - %s' % segment_name)
+ self._add_marker(end, 'end - %s' % segment_name)
metrics[segment_name] = _raw_data_to_metrics(raw_metrics)
return metrics
+ def _add_marker(self, timestamp, marker_text):
+ if not self._active_collection:
+ raise BitsError(
+ 'markers can not be added without an active collection')
+ self._active_collection.add_marker(timestamp, marker_text)
+
def release_resources(self):
- self._client.stop_collection()
+ """Performs all the cleanup and export tasks.
+
+ In the way that Bits' is interfaced several tasks can not be performed
+ while a collection is still active (like exporting the data) and others
+ can only take place while the collection is still active (like adding
+ markers to a collection).
+
+ To workaround this unique workflow, the collections that are started
+ with the 'measure' method are not really stopped after the method
+ is unblocked, it is only stopped after this method is called.
+
+ All the export files (.7z.bits and monsoon-formatted file) are also
+ generated in this method.
+ """
+ if not self._active_collection:
+ raise BitsError(
+ 'Attempted to stop a collection without starting one')
+ self._client.add_markers(self._active_collection.name,
+ self._active_collection.markers_buffer)
+ self._client.stop_collection(self._active_collection.name)
+
+ export_file = os.path.join(
+ context.get_current_context().get_full_output_path(),
+ '%s.7z.bits' % self._active_collection.name)
+ self._client.export(self._active_collection.name, export_file)
+ if self._active_collection.monsoon_output_path:
+ self._attempt_monsoon_format()
+ self._active_collection = None
+
+ def _attempt_monsoon_format(self):
+ """Attempts to create a monsoon-formatted file.
+
+ 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)
+ milli_amps_channel = None
+
+ for channel in available_channels:
+ if channel.endswith(self._root_rail):
+ milli_amps_channel = self._root_rail
+ break
+
+ if milli_amps_channel is None:
+ logging.debug('No monsoon equivalent channels were found when '
+ 'attempting to recreate monsoon file format. '
+ 'Available channels were: %s',
+ str(available_channels))
+ return
+
+ logging.debug('Recreating monsoon file format from channel: %s',
+ milli_amps_channel)
+ self._client.export_as_monsoon_format(
+ self._active_collection.monsoon_output_path,
+ self._active_collection.name,
+ milli_amps_channel)
+
+ def get_waveform(self, file_path=None):
+ """Parses a file generated in release_resources.
+
+ Args:
+ file_path: Path to a waveform file.
+
+ Returns:
+ A list of tuples in which the first element is a timestamp and the
+ second element is the sampled current at that time.
+ """
+ if file_path is None:
+ raise ValueError('file_path can not be None')
+
+ return list(power_metrics.import_raw_data(file_path))
def teardown(self):
if self._service is None:
diff --git a/acts/framework/acts/controllers/bits_lib/bits_client.py b/acts/framework/acts/controllers/bits_lib/bits_client.py
index 4c8e740..f33c44b 100644
--- a/acts/framework/acts/controllers/bits_lib/bits_client.py
+++ b/acts/framework/acts/controllers/bits_lib/bits_client.py
@@ -14,15 +14,13 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import logging
-import os
-import uuid
-import tempfile
-import yaml
+import csv
from datetime import datetime
+import logging
+import tempfile
from acts.libs.proc import job
-from acts import context
+import yaml
class BitsClientError(Exception):
@@ -52,26 +50,6 @@
'nanoseconds.' % type(timestamp))
-class _BitsCollection(object):
- """Object that represents a bits collection
-
- Attributes:
- name: The name given to the collection.
- markers_buffer: An array of un-flushed markers, each marker is
- represented by a bi-dimensional tuple with the format
- (<nanoseconds_since_epoch or datetime>, <text>).
- """
- def __init__(self, name):
- self.name = name
- self.markers_buffer = []
-
- def add_marker(self, timestamp, marker_text):
- self.markers_buffer.append((timestamp, marker_text))
-
- def clear_markers_buffer(self):
- self.markers_buffer.clear()
-
-
class BitsClient(object):
"""Helper class to issue bits' commands"""
@@ -89,115 +67,159 @@
self._binary = binary
self._service = service
self._server_config = service_config
- self._active_collection = None
- self._collections_counter = 0
def _acquire_monsoon(self):
"""Gets hold of a Monsoon so no other processes can use it.
Only works if there is a monsoon."""
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--collector',
- 'Monsoon',
- '--collector_cmd',
- 'acquire_monsoon']
- self._log.info('acquiring monsoon')
- job.run(cmd, timeout=10)
+ self._log.debug('acquiring monsoon')
+ self.run_cmd('--collector',
+ 'Monsoon',
+ '--collector_cmd',
+ 'acquire_monsoon', timeout=10)
def _release_monsoon(self):
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--collector',
- 'Monsoon',
- '--collector_cmd',
- 'release_monsoon']
- self._log.info('releasing monsoon')
- job.run(cmd, timeout=10)
+ self._log.debug('releasing monsoon')
+ self.run_cmd('--collector',
+ 'Monsoon',
+ '--collector_cmd',
+ 'release_monsoon', timeout=10)
- def _export(self):
- collection_path = os.path.join(
- context.get_current_context().get_full_output_path(),
- '%s.7z.bits' % self._active_collection.name)
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--name',
- self._active_collection.name,
- '--ignore_gaps',
- '--export',
- '--export_path',
- collection_path]
- self._log.info('exporting collection %s to %s',
- self._active_collection.name,
- collection_path)
- job.run(cmd, timeout=600)
-
- def _flush_markers(self):
- for ts, marker in sorted(self._active_collection.markers_buffer,
- key=lambda x: x[0]):
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--name',
- self._active_collection.name,
- '--log_ts',
- str(_to_ns(ts)),
- '--log',
- marker]
- job.run(cmd, timeout=10)
- self._active_collection.clear_markers_buffer()
-
- def add_marker(self, timestamp, marker_text):
- """Buffers a marker for the active collection.
-
- Bits does not allow inserting markers with timestamps out of order.
- The buffer of markers will be flushed when the collection is stopped to
- ensure all the timestamps are input in order.
+ def run_cmd(self, *args, timeout=60):
+ """Executes a generic bits.par command.
Args:
- timestamp: Numerical nanoseconds since epoch or datetime.
- marker_text: A string to label this marker with.
+ args: A bits.par command as a tokenized array. The path to the
+ binary and the service port are provided by default, cmd should
+ only contain the remaining tokens of the desired command.
+ timeout: Number of seconds to wait for the command to finish before
+ forcibly killing it.
"""
- if not self._active_collection:
- raise BitsClientError(
- 'markers can not be added without an active collection')
- self._active_collection.add_marker(timestamp, marker_text)
+ result = job.run([self._binary, '--port',
+ self._service.port] + [str(arg) for arg in args],
+ timeout=timeout)
+ return result.stdout
- def get_metrics(self, start, end):
+ def export(self, collection_name, path):
+ """Exports a collection to its bits persistent format.
+
+ Exported files can be shared and opened through the Bits UI.
+
+ Args:
+ collection_name: Collection to be exported.
+ path: Where the resulting file should be created. Bits requires that
+ the resulting file ends in .7z.bits.
+ """
+ if not path.endswith('.7z.bits'):
+ raise BitsClientError('Bits\' collections can only be exported to '
+ 'files ending in .7z.bits, got %s' % path)
+ self._log.debug('exporting collection %s to %s',
+ collection_name,
+ path)
+ self.run_cmd('--name',
+ collection_name,
+ '--ignore_gaps',
+ '--export',
+ '--export_path',
+ path,
+ timeout=600)
+
+ def export_as_csv(self, channels, collection_name, output_file):
+ """Export bits data as CSV.
+
+ Writes the selected channel data to the given output_file. Note that
+ the first line of the file contains headers.
+
+ Args:
+ channels: A list of string pattern matches for the channel to be
+ retrieved. For example, ":mW" will export all power channels,
+ ":mV" will export all voltage channels, "C1_01__" will export
+ power/voltage/current for the first fail of connector 1.
+ collection_name: A string for a collection that is sampling.
+ output_file: A string file path where the CSV will be written.
+ """
+ channels_arg = ','.join(channels)
+ cmd = ['--csvfile',
+ output_file,
+ '--name',
+ collection_name,
+ '--ignore_gaps',
+ '--csv_rawtimestamps',
+ '--channels',
+ channels_arg]
+ if self._server_config.has_virtual_metrics_file:
+ cmd = cmd + ['--vm_file', 'default']
+ self._log.debug(
+ 'exporting csv for collection %s to %s, with channels %s',
+ collection_name, output_file, channels_arg)
+ self.run_cmd(*cmd, timeout=600)
+
+ def add_markers(self, collection_name, markers):
+ """Appends markers to a collection.
+
+ These markers are displayed in the Bits UI and are useful to label
+ important test events.
+
+ Markers can only be added to collections that have not been
+ closed / stopped. Markers need to be added in chronological order,
+ this function ensures that at least the markers added in each
+ call are sorted in chronological order, but if this function
+ is called multiple times, then is up to the user to ensure that
+ the subsequent batches of markers are for timestamps higher (newer)
+ than all the markers passed in previous calls to this function.
+
+ Args:
+ collection_name: The name of the collection to add markers to.
+ markers: A list of tuples of the shape:
+
+ [(<nano_seconds_since_epoch or datetime>, <marker text>),
+ (<nano_seconds_since_epoch or datetime>, <marker text>),
+ (<nano_seconds_since_epoch or datetime>, <marker text>),
+ ...
+ ]
+ """
+ # sorts markers in chronological order before adding them. This is
+ # required by go/pixel-bits
+ for ts, marker in sorted(markers, key=lambda x: _to_ns(x[0])):
+ self._log.debug('Adding marker at %s: %s', str(ts), marker)
+ self.run_cmd('--name',
+ collection_name,
+ '--log_ts',
+ str(_to_ns(ts)),
+ '--log',
+ marker,
+ timeout=10)
+
+ def get_metrics(self, collection_name, start=None, end=None):
"""Extracts metrics for a period of time.
Args:
+ collection_name: The name of the collection to get metrics from
start: Numerical nanoseconds since epoch until the start of the
- period of interest or datetime.
+ period of interest or datetime. If not provided, start will be the
+ beginning of the collection.
end: Numerical nanoseconds since epoch until the end of the
- period of interest or datetime.
+ period of interest or datetime. If not provided, end will be the
+ end of the collection.
"""
- if not self._active_collection:
- raise BitsClientError(
- 'metrics can not be collected without an active collection')
-
with tempfile.NamedTemporaryFile(prefix='bits_metrics') as tf:
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--name',
- self._active_collection.name,
+ cmd = ['--name',
+ collection_name,
'--ignore_gaps',
- '--abs_start_time',
- str(_to_ns(start)),
- '--abs_stop_time',
- str(_to_ns(end)),
'--aggregates_yaml_path',
tf.name]
+
+ if start is not None:
+ cmd = cmd + ['--abs_start_time', str(_to_ns(start))]
+ if end is not None:
+ cmd = cmd + ['--abs_stop_time', str(_to_ns(end))]
if self._server_config.has_virtual_metrics_file:
cmd = cmd + ['--vm_file', 'default']
- job.run(cmd)
+
+ self.run_cmd(*cmd)
with open(tf.name) as mf:
self._log.debug(
'bits aggregates for collection %s [%s-%s]: %s' % (
- self._active_collection.name, start, end,
+ collection_name, start, end,
mf.read()))
with open(tf.name) as mf:
@@ -205,82 +227,53 @@
def disconnect_usb(self):
"""Disconnects the monsoon's usb. Only works if there is a monsoon"""
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--collector',
- 'Monsoon',
- '--collector_cmd',
- 'usb_disconnect']
- self._log.info('disconnecting monsoon\'s usb')
- job.run(cmd, timeout=10)
+ self._log.debug('disconnecting monsoon\'s usb')
+ self.run_cmd('--collector',
+ 'Monsoon',
+ '--collector_cmd',
+ 'usb_disconnect', timeout=10)
- def start_collection(self, postfix=None):
+ def start_collection(self, collection_name, default_sampling_rate=1000):
"""Indicates Bits to start a collection.
Args:
- postfix: Optional argument that can be used to identify the
- collection with.
+ collection_name: Name to give to the collection to be started.
+ Collection names must be unique at Bits' service level. If multiple
+ collections must be taken within the context of the same Bits'
+ service, ensure that each collection is given a different one.
+ default_sampling_rate: Samples per second to be collected
"""
- if self._active_collection:
- raise BitsClientError(
- 'Attempted to start a collection while there is still an '
- 'active one. Active collection: %s',
- self._active_collection.name)
- self._collections_counter = self._collections_counter + 1
- # The name gets a random 8 characters salt suffix because the Bits
- # client has a bug where files with the same name are considered to be
- # the same collection and it won't load two files with the same name.
- # b/153170987 b/153944171
- if not postfix:
- postfix = str(self._collections_counter)
- postfix = '%s_%s' % (postfix, str(uuid.uuid4())[0:8])
- self._active_collection = _BitsCollection(
- 'bits_collection_%s' % postfix)
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--name',
- self._active_collection.name,
+ cmd = ['--name',
+ collection_name,
'--non_blocking',
'--time',
ONE_YEAR,
'--default_sampling_rate',
- '1000',
- '--disk_space_saver']
- self._log.info('starting collection %s', self._active_collection.name)
- job.run(cmd, timeout=10)
+ str(default_sampling_rate)]
+
+ if self._server_config.has_kibbles:
+ cmd = cmd + ['--disk_space_saver']
+
+ self._log.debug('starting collection %s', collection_name)
+ self.run_cmd(*cmd, timeout=10)
def connect_usb(self):
"""Connects the monsoon's usb. Only works if there is a monsoon."""
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--collector',
+ cmd = ['--collector',
'Monsoon',
'--collector_cmd',
'usb_connect']
- self._log.info('connecting monsoon\'s usb')
- job.run(cmd, timeout=10)
+ self._log.debug('connecting monsoon\'s usb')
+ self.run_cmd(*cmd, timeout=10)
- def stop_collection(self):
+ def stop_collection(self, collection_name):
"""Stops the active collection."""
- if not self._active_collection:
- raise BitsClientError(
- 'Attempted to stop a collection without starting one')
- self._log.info('stopping collection %s', self._active_collection.name)
- self._flush_markers()
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--name',
- self._active_collection.name,
- '--stop']
- job.run(cmd)
- self._export()
- self._log.info('stopped collection %s', self._active_collection.name)
- self._active_collection = None
+ self._log.debug('stopping collection %s', collection_name)
+ self.run_cmd('--name',
+ collection_name,
+ '--stop')
+ self._log.debug('stopped collection %s', collection_name)
def list_devices(self):
"""Lists devices managed by the bits_server this client is connected
@@ -289,11 +282,54 @@
Returns:
bits' output when called with --list devices.
"""
- cmd = [self._binary,
- '--port',
- self._service.port,
- '--list',
- 'devices']
self._log.debug('listing devices')
- result = job.run(cmd, timeout=20)
- return result.stdout
+ result = self.run_cmd('--list', 'devices', timeout=20)
+ return result
+
+ def list_channels(self, collection_name):
+ """Finds all the available channels in a given collection.
+
+ Args:
+ collection_name: The name of the collection to get channels from.
+ """
+ metrics = self.get_metrics(collection_name)
+ return [channel['name'] for channel in metrics['data']]
+
+ def export_as_monsoon_format(self, dest_path, collection_name,
+ channel_pattern):
+ """Exports data from a collection in monsoon style.
+
+ This function exists because there are tools that have been built on
+ top of the monsoon format. To be able to leverage such tools we need
+ to make the data compliant with the format.
+
+ The monsoon format is:
+
+ <time_since_epoch_in_secs> <amps>
+
+ Args:
+ dest_path: Path where the resulting file will be generated.
+ collection_name: The name of the Bits' collection to export data
+ from.
+ channel_pattern: A regex that matches the Bits' channel to be used
+ as source of data. If there are multiple matching channels, only the
+ first one will be used. The channel is always assumed to be
+ expressed en milli-amps, the resulting format requires amps, so the
+ values coming from the first matching channel will always be
+ multiplied by 1000.
+ """
+ with tempfile.NamedTemporaryFile(prefix='bits_csv_') as tmon:
+ self.export_as_csv([channel_pattern], collection_name, tmon.name)
+
+ self._log.debug(
+ 'massaging bits csv to monsoon format for collection'
+ ' %s', collection_name)
+ with open(tmon.name) as csv_file:
+ reader = csv.reader(csv_file)
+ headers = next(reader)
+ self._log.debug('csv headers %s', headers)
+ with open(dest_path, 'w') as dest:
+ for row in reader:
+ ts = float(row[0]) / 1e9
+ amps = float(row[1]) / 1e3
+ dest.write('%.7f %.12f\n' % (ts, amps))
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 b17ff3b..cb2d219 100644
--- a/acts/framework/acts/controllers/bits_lib/bits_service_config.py
+++ b/acts/framework/acts/controllers/bits_lib/bits_service_config.py
@@ -62,8 +62,8 @@
raise ValueError('Monsoon voltage can not be undefined. Received '
'config was: %s' % monsoon_config)
- self.serial_num = monsoon_config['serial_num']
- self.monsoon_voltage = monsoon_config['monsoon_voltage']
+ self.serial_num = int(monsoon_config['serial_num'])
+ self.monsoon_voltage = float(monsoon_config['monsoon_voltage'])
self.config_dic = copy.deepcopy(DEFAULT_MONSOON_CONFIG_DICT)
if float(self.serial_num) >= 20000:
diff --git a/acts/framework/acts/controllers/gnss_lib/GnssSimulator.py b/acts/framework/acts/controllers/gnss_lib/GnssSimulator.py
new file mode 100644
index 0000000..7f64164
--- /dev/null
+++ b/acts/framework/acts/controllers/gnss_lib/GnssSimulator.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 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.
+"""
+Python module for General abstract GNSS Simulator.
+@author: Clay Liao (jianhsiungliao@)
+"""
+from time import sleep
+from acts.controllers.spectracom_lib import gsg6
+from acts.controllers.spirent_lib import gss7000
+from acts import logger
+from acts.utils import ping
+from acts.libs.proc import job
+
+
+class AbstractGnssSimulator:
+ """General abstract GNSS Simulator"""
+
+ def __init__(self, simulator, ip_addr, ip_port, ip_port_ctrl=7717):
+ """Init AbstractGnssSimulator
+
+ Args:
+ simulator: GNSS simulator name,
+ Type, str
+ Option 'gss7000/gsg6'
+ ip_addr: IP Address.
+ Type, str
+ ip_port: TCPIP Port,
+ Type, str
+ ip_port_ctrl: TCPIP port,
+ Type, int
+ Default, 7717
+ """
+ self.simulator_name = str(simulator).lower()
+ self.ip_addr = ip_addr
+ self.ip_port = ip_port
+ self.ip_port_ctrl = ip_port_ctrl
+ self._logger = logger.create_tagged_trace_logger(
+ '%s %s:%s' % (simulator, self.ip_addr, self.ip_port))
+ if self.simulator_name == 'gsg6':
+ self._logger.info('GNSS simulator is GSG6')
+ self.simulator = gsg6.GSG6(self.ip_addr, self.ip_port)
+ elif self.simulator_name == 'gss7000':
+ self._logger.info('GNSS simulator is GSS7000')
+ self.simulator = gss7000.GSS7000(self.ip_addr, self.ip_port,
+ self.ip_port_ctrl)
+ else:
+ self._logger.error('No matched GNSS simulator')
+ raise AttributeError(
+ 'The GNSS simulator in config file is {} which is not supported.'
+ .format(self.simulator_name))
+
+ def connect(self):
+ """Connect to GNSS Simulator"""
+ self._logger.debug('Connect to GNSS Simulator {}'.format(
+ self.simulator_name.upper()))
+ self.simulator.connect()
+
+ def close(self):
+ """Disconnect from GNSS Simulator"""
+ self._logger.debug('Disconnect from GNSS Simulator {}'.format(
+ self.simulator_name.upper()))
+ self.simulator.close()
+
+ def start_scenario(self, scenario=''):
+ """Start the running scenario.
+
+ Args:
+ scenario: path of scenario,
+ Type, str
+ """
+ self._logger.info('Start GNSS Scenario {}'.format(scenario))
+ self.simulator.start_scenario(scenario)
+
+ def stop_scenario(self):
+ """Stop the running scenario."""
+ self._logger.debug('Stop playing scenario')
+ self.simulator.stop_scenario()
+
+ def set_power(self, power_level=-130):
+ """Set scenario power level.
+ Args:
+ power_level: target power level in dBm for gsg6 or gss7000,
+ gsg6 power_level range is [-160, -65],
+ gss7000 power_level range is [-170, -115]
+ Type, float,
+ """
+ self.simulator.set_power(power_level)
+
+ def set_power_offset(self, gss7000_ant=1, pwr_offset=0):
+ """Set scenario power level offset based on reference level.
+ The default reference level is -130dBm for GPS L1.
+ Args:
+ ant: target gss7000 RF port,
+ Type, int
+ pwr_offset: target power offset in dB,
+ Type, float
+ """
+ if self.simulator_name == 'gsg6':
+ power_level = -130 + pwr_offset
+ self.simulator.set_power(power_level)
+ elif self.simulator_name == 'gss7000':
+ self.simulator.set_power_offset(gss7000_ant, pwr_offset)
+ else:
+ self._logger.error('No GNSS simulator is available')
+
+ def set_scenario_power(self,
+ power_level,
+ sat_id='',
+ sat_system='',
+ freq_band=''):
+ """Set dynamic power for the running scenario.
+
+ Args:
+ power_level: transmit power level
+ Type, float.
+ Decimal, unit [dBm]
+ sat_id: set power level for specific satellite identifiers
+ Type, str.
+ Option
+ For GSG-6: 'Gxx/Rxx/Exx/Cxx/Jxx/Ixx/Sxxx'
+ where xx is satellite identifiers number
+ e.g.: G10
+ For GSS7000: Provide SVID.
+ Default, '', assumed All.
+ sat_system: to set power level for all Satellites
+ Type, str
+ Option [GPS, GLO, GAL, BDS, QZSS, IRNSS, SBAS]
+ Default, '', assumed All.
+ freq_band: Frequency band to set the power level
+ Type, str
+ Default, '', assumed to be L1.
+ Raises:
+ RuntimeError: raise when instrument does not support this function.
+ """
+ self.simulator.set_scenario_power(power_level=power_level,
+ sat_id=sat_id,
+ sat_system=sat_system,
+ freq_band=freq_band)
+
+ def toggle_scenario_power(self,
+ toggle_onoff='ON',
+ sat_id='',
+ sat_system=''):
+ """Toggle ON OFF scenario.
+
+ Args:
+ toggle_onoff: turn on or off the satellites
+ Type, str. Option ON/OFF
+ Default, 'ON'
+ sat_id: satellite identifiers
+ Type, str.
+ Option 'Gxx/Rxx/Exx/Cxx/Jxx/Ixx/Sxxx'
+ where xx is satellite identifiers no.
+ e.g.: G10
+ sat_system: to toggle On/OFF for all Satellites
+ Type, str
+ Option 'GPS/GLO/GAL'
+ """
+ # TODO: [b/208719212] Currently only support GSG-6. Will implement GSS7000 feature.
+ if self.simulator_name == 'gsg6':
+ self.simulator.toggle_scenario_power(toggle_onoff=toggle_onoff,
+ sat_id=sat_id,
+ sat_system=sat_system)
+ else:
+ raise RuntimeError('{} does not support this function'.format(
+ self.simulator_name))
+
+ def ping_inst(self, retry=3, wait=1):
+ """Ping IP of instrument to check if the connection is stable.
+ Args:
+ retry: Retry times.
+ Type, int.
+ Default, 3.
+ wait: Wait time between each ping command when ping fail is met.
+ Type, int.
+ Default, 1.
+ Return:
+ True/False of ping result.
+ """
+ for i in range(retry):
+ ret = ping(job, self.ip_addr)
+ self._logger.debug(f'Ping return results: {ret}')
+ if ret.get('packet_loss') == '0':
+ return True
+ self._logger.warning(f'Fail to ping GNSS Simulator: {i+1}')
+ sleep(wait)
+ return False
diff --git a/acts/framework/acts/controllers/gnss_lib/__init__.py b/acts/framework/acts/controllers/gnss_lib/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts/framework/acts/controllers/gnss_lib/__init__.py
diff --git a/acts/framework/acts/controllers/iperf_server.py b/acts/framework/acts/controllers/iperf_server.py
index 78cb787..4be9d1e 100755
--- a/acts/framework/acts/controllers/iperf_server.py
+++ b/acts/framework/acts/controllers/iperf_server.py
@@ -243,8 +243,8 @@
"""
if not self._has_data():
return None
- instantaneous_rates = self.instantaneous_rates[iperf_ignored_interval:
- -1]
+ instantaneous_rates = self.instantaneous_rates[
+ iperf_ignored_interval:-1]
avg_rate = math.fsum(instantaneous_rates) / len(instantaneous_rates)
sqd_deviations = ([(rate - avg_rate)**2
for rate in instantaneous_rates])
@@ -497,6 +497,18 @@
self.start_ssh()
utils.renew_linux_ip_address(self._ssh_session, self.test_interface)
+ def _cleanup_iperf_port(self):
+ """Checks and kills zombie iperf servers occupying intended port."""
+ iperf_check_cmd = ('netstat -tulpn | grep LISTEN | grep iperf3'
+ ' | grep :{}').format(self.port)
+ iperf_check = self._ssh_session.run(iperf_check_cmd,
+ ignore_status=True)
+ iperf_check = iperf_check.stdout
+ if iperf_check:
+ logging.debug('Killing zombie server on port {}'.format(self.port))
+ iperf_pid = iperf_check.split(' ')[-1].split('/')[0]
+ self._ssh_session.run('kill -9 {}'.format(str(iperf_pid)))
+
def start(self, extra_args='', tag='', iperf_binary=None):
"""Starts iperf server on specified machine and port.
@@ -513,6 +525,7 @@
if not self._ssh_session:
self.start_ssh()
+ self._cleanup_iperf_port()
if not iperf_binary:
logging.debug('No iperf3 binary specified. '
'Assuming iperf3 is in the path.')
diff --git a/acts/framework/acts/controllers/power_metrics.py b/acts/framework/acts/controllers/power_metrics.py
index f4d9edd..98599fe 100644
--- a/acts/framework/acts/controllers/power_metrics.py
+++ b/acts/framework/acts/controllers/power_metrics.py
@@ -15,6 +15,7 @@
# limitations under the License.
import math
+import numpy as np
# Metrics timestamp keys
START_TIMESTAMP = 'start'
@@ -166,6 +167,57 @@
yield float(time[:-1]), float(sample)
+def generate_percentiles(monsoon_file, timestamps, percentiles):
+ """Generates metrics .
+
+ Args:
+ monsoon_file: monsoon-like file where each line has two
+ numbers separated by a space, in the format:
+ seconds_since_epoch amperes
+ seconds_since_epoch amperes
+ timestamps: dict following the output format of
+ instrumentation_proto_parser.get_test_timestamps()
+ percentiles: percentiles to be returned
+ """
+ if timestamps is None:
+ timestamps = {}
+ test_starts = {}
+ test_ends = {}
+ for seg_name, times in timestamps.items():
+ if START_TIMESTAMP in times and END_TIMESTAMP in times:
+ test_starts[seg_name] = Metric(
+ times[START_TIMESTAMP], TIME, MILLISECOND).to_unit(
+ SECOND).value
+ test_ends[seg_name] = Metric(
+ times[END_TIMESTAMP], TIME, MILLISECOND).to_unit(
+ SECOND).value
+
+ arrays = {}
+ for seg_name in test_starts:
+ arrays[seg_name] = []
+
+ with open(monsoon_file, 'r') as m:
+ for line in m:
+ timestamp = float(line.strip().split()[0])
+ value = float(line.strip().split()[1])
+ for seg_name in arrays.keys():
+ if test_starts[seg_name] <= timestamp <= test_ends[seg_name]:
+ arrays[seg_name].append(value)
+
+ results = {}
+ for seg_name in arrays:
+ if len(arrays[seg_name]) == 0:
+ continue
+
+ pairs = zip(percentiles, np.percentile(arrays[seg_name],
+ percentiles))
+ results[seg_name] = [
+ Metric.amps(p[1], 'percentile_%s' % p[0]).to_unit(MILLIAMP) for p in
+ pairs
+ ]
+ return results
+
+
def generate_test_metrics(raw_data, timestamps=None,
voltage=None):
"""Split the data into individual test metrics, based on the timestamps
@@ -185,28 +237,18 @@
test_ends = {}
test_metrics = {}
for seg_name, times in timestamps.items():
- test_metrics[seg_name] = PowerMetrics(voltage)
- try:
+ if START_TIMESTAMP in times and END_TIMESTAMP in times:
+ test_metrics[seg_name] = PowerMetrics(voltage)
test_starts[seg_name] = Metric(
times[START_TIMESTAMP], TIME, MILLISECOND).to_unit(
SECOND).value
- except KeyError:
- raise ValueError(
- 'Missing start timestamp for test scenario "%s". Refer to '
- 'instrumentation_proto.txt for details.' % seg_name)
- try:
test_ends[seg_name] = Metric(
times[END_TIMESTAMP], TIME, MILLISECOND).to_unit(
SECOND).value
- except KeyError:
- raise ValueError(
- 'Missing end timestamp for test scenario "%s". Test '
- 'scenario may have terminated with errors. Refer to '
- 'instrumentation_proto.txt for details.' % seg_name)
# Assign data to tests based on timestamps
for timestamp, amps in raw_data:
- for seg_name in timestamps:
+ for seg_name in test_metrics.keys():
if test_starts[seg_name] <= timestamp <= test_ends[seg_name]:
test_metrics[seg_name].update_metrics(amps)
diff --git a/acts/framework/acts/controllers/spectracom_lib/gsg6.py b/acts/framework/acts/controllers/spectracom_lib/gsg6.py
index a1c30cc..ef381e2 100644
--- a/acts/framework/acts/controllers/spectracom_lib/gsg6.py
+++ b/acts/framework/acts/controllers/spectracom_lib/gsg6.py
@@ -1,18 +1,3 @@
-#!/usr/bin/env python3
-#
-# Copyright 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.
"""Python module for Spectracom/Orolia GSG-6 GNSS simulator."""
from acts.controllers import abstract_inst
@@ -115,8 +100,8 @@
self._send(':SOUR:POW ' + str(round(power_level, 1)))
- infmsg = 'Set GSG-6 transmit power to "{}"'.format(
- round(power_level, 1))
+ infmsg = 'Set GSG-6 transmit power to "{}"'.format(round(
+ power_level, 1))
self._logger.debug(infmsg)
def get_nmealog(self):
@@ -128,3 +113,107 @@
nmea_data = self._query('SOUR:SCEN:LOG?')
return nmea_data
+
+ def toggle_scenario_power(self,
+ toggle_onoff='ON',
+ sat_id='',
+ sat_system=''):
+ """Toggle ON OFF scenario.
+
+ Args:
+ toggle_onoff: turn on or off the satellites
+ Type, str. Option ON/OFF
+ Default, 'ON'
+ sat_id: satellite identifiers
+ Type, str.
+ Option 'Gxx/Rxx/Exx/Cxx/Jxx/Ixx/Sxxx'
+ where xx is satellite identifiers no.
+ e.g.: G10
+ sat_system: to toggle On/OFF for all Satellites
+ Type, str
+ Option [GPS, GLO, GAL, BDS, QZSS, IRNSS, SBAS]
+ Raises:
+ GSG6Error: raise when toggle is not set.
+ """
+ if not sat_id and not sat_system:
+ self._send(':SOUR:SCEN:POW ' + str(toggle_onoff))
+ infmsg = 'Set GSG-6 Power to "{}"'.format(toggle_onoff)
+ self._logger.debug(infmsg)
+
+ elif sat_id and not sat_system:
+ self._send(':SOUR:SCEN:POW ' + str(sat_id) + ',' +
+ str(toggle_onoff))
+ infmsg = ('Set GSG-6 Power to "{}" for "{}" satellite '
+ 'identifiers').format(toggle_onoff, sat_id)
+ self._logger.debug(infmsg)
+
+ elif not sat_id and sat_system:
+ self._send(':SOUR:SCEN:POW ' + str(sat_system) + ',' +
+ str(toggle_onoff))
+ infmsg = 'Set GSG-6 Power to "{}" for "{}" satellite system'.format(
+ toggle_onoff, sat_system)
+ self._logger.debug(infmsg)
+
+ else:
+ errmsg = ('"toggle power" must have either of these value [ON/OFF],'
+ ' current input is {}').format(str(toggle_onoff))
+ raise GSG6Error(error=errmsg, command='toggle_scenario_power')
+
+ def set_scenario_power(self,
+ power_level,
+ sat_id='',
+ sat_system='',
+ freq_band=''):
+ """Set dynamic power for the running scenario.
+
+ Args:
+ power_level: transmit power level
+ Type, float.
+ Decimal, unit [dBm]
+ sat_id: set power level for specific satellite identifiers
+ Type, str. Option
+ 'Gxx/Rxx/Exx/Cxx/Jxx/Ixx/Sxxx'
+ where xx is satellite identifiers number
+ e.g.: G10
+ sat_system: to set power level for all Satellites
+ Type, str
+ Option [GPS, GLO, GAL, BDS, QZSS, IRNSS, SBAS]
+ freq_band: Frequency band to set the power level
+ Type, str
+ Option [L1, L2, L5, ALL]
+ Default, '', assumed to be L1.
+ Raises:
+ GSG6Error: raise when power level is not in [-160, -65] range.
+ """
+ if freq_band == 'ALL':
+ if not -100 <= power_level <= 100:
+ errmsg = ('"power_level" must be within [-100, 100], for '
+ '"freq_band"="ALL", current input is {}').format(
+ str(power_level))
+ raise GSG6Error(error=errmsg, command='set_scenario_power')
+ else:
+ if not -160 <= power_level <= -65:
+ errmsg = ('"power_level" must be within [-160, -65], for '
+ '"freq_band" != "ALL", current input is {}').format(
+ str(power_level))
+ raise GSG6Error(error=errmsg, command='set_scenario_power')
+
+ if sat_id and not sat_system:
+ self._send(':SOUR:SCEN:POW ' + str(sat_id) + ',' +
+ str(round(power_level, 1)) + ',' + str(freq_band))
+ infmsg = ('Set GSG-6 transmit power to "{}" for "{}" '
+ 'satellite id').format(round(power_level, 1), sat_id)
+ self._logger.debug(infmsg)
+
+ elif not sat_id and sat_system:
+ self._send(':SOUR:SCEN:POW ' + str(sat_system) + ',' +
+ str(round(power_level, 1)) + ',' + str(freq_band))
+ infmsg = ('Set GSG-6 transmit power to "{}" for "{}" '
+ 'satellite system').format(round(power_level, 1),
+ sat_system)
+ self._logger.debug(infmsg)
+
+ else:
+ errmsg = ('sat_id or sat_system must have value, current input of '
+ 'sat_id {} and sat_system {}').format(sat_id, sat_system)
+ raise GSG6Error(error=errmsg, command='set_scenario_power')
diff --git a/acts/framework/acts/controllers/spirent_lib/gss7000.py b/acts/framework/acts/controllers/spirent_lib/gss7000.py
new file mode 100644
index 0000000..961d4e8
--- /dev/null
+++ b/acts/framework/acts/controllers/spirent_lib/gss7000.py
@@ -0,0 +1,490 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 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.
+"""
+Python module for Spirent GSS7000 GNSS simulator.
+@author: Clay Liao (jianhsiungliao@)
+"""
+from time import sleep
+import xml.etree.ElementTree as ET
+from acts.controllers import abstract_inst
+
+
+def get_xml_text(xml_string='', tag=''):
+ """Parse xml from string and return specific tag
+
+ Args:
+ xml_string: xml string,
+ Type, Str.
+ tag: tag in xml,
+ Type, Str.
+
+ Returns:
+ text: Text content in the tag
+ Type, Str.
+ """
+ if xml_string and tag:
+ root = ET.fromstring(xml_string)
+ try:
+ text = str(root.find(tag).text).rstrip().lstrip()
+ except ValueError:
+ text = 'INVALID DATA'
+ else:
+ text = 'INVALID DATA'
+ return text
+
+
+class GSS7000Error(abstract_inst.SocketInstrumentError):
+ """GSS7000 Instrument Error Class."""
+
+
+class AbstractInstGss7000(abstract_inst.SocketInstrument):
+ """Abstract instrument for GSS7000"""
+
+ def _query(self, cmd):
+ """query instrument via Socket.
+
+ Args:
+ cmd: Command to send,
+ Type, Str.
+
+ Returns:
+ resp: Response from Instrument via Socket,
+ Type, Str.
+ """
+ self._send(cmd)
+ self._wait()
+ resp = self._recv()
+ return resp
+
+ def _wait(self, wait_time=1):
+ """wait function
+ Args:
+ wait_time: wait time in sec.
+ Type, int,
+ Default, 1.
+ """
+ sleep(wait_time)
+
+
+class GSS7000Ctrl(AbstractInstGss7000):
+ """GSS7000 control daemon class"""
+
+ def __init__(self, ip_addr, ip_port=7717):
+ """Init method for GSS7000 Control Daemon.
+
+ Args:
+ ip_addr: IP Address.
+ Type, str.
+ ip_port: TCPIP Port.
+ Type, str.
+ """
+ super().__init__(ip_addr, ip_port)
+ self.idn = 'Spirent-GSS7000 Control Daemon'
+
+ def connect(self):
+ """Init and Connect to GSS7000 Control Daemon."""
+ # Connect socket then connect socket again
+ self._close_socket()
+ self._connect_socket()
+ # Stop GSS7000 Control Daeamon Then Start
+ self._query('STOP_ENGINE')
+ self._wait()
+ self._query('START_ENGINE')
+
+ def close(self):
+ """Close GSS7000 control daemon"""
+ self._close_socket()
+ self._logger.debug('Closed connection to GSS7000 control daemon')
+
+
+class GSS7000(AbstractInstGss7000):
+ """GSS7000 Class, inherted from abstract_inst SocketInstrument."""
+
+ def __init__(self, ip_addr, engine_ip_port=15650, ctrl_ip_port=7717):
+ """Init method for GSS7000.
+
+ Args:
+ ip_addr: IP Address.
+ Type, str.
+ engine_ip_port: TCPIP Port for
+ Type, str.
+ ctrl_ip_port: TCPIP Port for Control Daemon
+ """
+ super().__init__(ip_addr, engine_ip_port)
+ self.idn = ''
+ self.connected = False
+ self.capability = []
+ self.gss7000_ctrl_daemon = GSS7000Ctrl(ip_addr, ctrl_ip_port)
+ # Close control daemon and engine sockets at the beginning
+ self.gss7000_ctrl_daemon._close_socket()
+ self._close_socket()
+
+ def connect(self):
+ """Connect GSS7000 engine daemon"""
+ # Connect control daemon socket
+ self._logger.debug('Connect to GSS7000')
+ self.gss7000_ctrl_daemon.connect()
+ # Connect to remote engine socket
+ self._wait()
+ self._connect_socket()
+ self.connected = True
+ self.get_hw_capability()
+
+ def close(self):
+ """Close GSS7000 engine daemon"""
+ # Close GSS7000 control daemon
+ self.gss7000_ctrl_daemon.close()
+ # Close GSS7000 engine daemon
+ self._close_socket()
+ self._logger.debug('Closed connection to GSS7000 engine daemon')
+
+ def _parse_hw_cap(self, xml):
+ """Parse GSS7000 hardware capability xml to list.
+ Args:
+ xml: hardware capability xml,
+ Type, str.
+
+ Returns:
+ capability: Hardware capability dictionary
+ Type, list.
+ """
+ root = ET.fromstring(xml)
+ capability_ls = list()
+ sig_cap_list = root.find('data').find('Signal_capabilities').findall(
+ 'Signal')
+ for signal in sig_cap_list:
+ value = str(signal.text).rstrip().lstrip()
+ capability_ls.extend(value.upper().split(' '))
+ return capability_ls
+
+ def get_hw_capability(self):
+ """Check GSS7000 hardware capability
+
+ Returns:
+ capability: Hardware capability dictionary,
+ Type, list.
+ """
+ if self.connected:
+ capability_xml = self._query('GET_LICENCED_HARDWARE_CAPABILITY')
+ self.capability = self._parse_hw_cap(capability_xml)
+
+ return self.capability
+
+ def get_idn(self):
+ """Get the SimREPLAYplus Version
+
+ Returns:
+ SimREPLAYplus Version
+ """
+ idn_xml = self._query('*IDN?')
+ self.idn = get_xml_text(idn_xml, 'data')
+ return self.idn
+
+ def load_scenario(self, scenario=''):
+ """Load the scenario.
+
+ Args:
+ scenario: path of scenario,
+ Type, str
+ """
+ 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
+
+ def start_scenario(self, scenario=''):
+ """Load and Start the running scenario.
+
+ Args:
+ scenario: path of scenario,
+ Type, str
+ """
+ if scenario:
+ if self.load_scenario(scenario):
+ self._query('RU')
+ else:
+ infmsg = 'No scenario is loaded. Stop running scenario'
+ self._logger.debug(infmsg)
+ else:
+ pass
+
+ if scenario:
+ infmsg = 'Started running scenario {}'.format(scenario)
+ else:
+ infmsg = 'Started running current scenario'
+
+ self._logger.debug(infmsg)
+
+ def get_scenario_name(self):
+ """Get current scenario name"""
+ sc_name_xml = self._query('SC_NAME')
+ return get_xml_text(sc_name_xml, 'data')
+
+ def stop_scenario(self):
+ """Stop the running scenario."""
+ self._query('-,EN,1')
+ self._logger.debug('Stopped running scenario')
+
+ def set_power_offset(self, ant=1, power_offset=0):
+ """Set Power Offset of GSS7000 Tx
+ Args:
+ ant: antenna number of GSS7000
+ power_offset: transmit power offset level
+ Type, float.
+ Decimal, unit [dB]
+
+ Raises:
+ GSS7000Error: raise when power offset level is not in [-49, 15] range.
+ """
+ if not -49 <= power_offset <= 15:
+ errmsg = (f'"power_offset" must be within [-49, 15], '
+ f'current input is {power_offset}')
+ raise GSS7000Error(error=errmsg, command='set_power_offset')
+
+ cmd = f'-,POW_LEV,V1_A{ant},{power_offset},GPS,0,0,1,1,1,1,0'
+ self._query(cmd)
+
+ infmsg = f'Set veichel 1 antenna {ant} power offset: {power_offset}'
+ self._logger.debug(infmsg)
+
+ def set_ref_power(self, ref_dBm=-130):
+ """Set Ref Power of GSS7000 Tx
+ Args:
+ ref_dBm: transmit reference power level in dBm for GSS7000
+ Type, float.
+ Decimal, unit [dBm]
+
+ Raises:
+ 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))
+ raise GSS7000Error(error=errmsg, command='set_ref_power')
+ cmd = 'REF_DBM,{}'.format(str(round(ref_dBm, 1)))
+ self._query(cmd)
+ infmsg = 'Set reference power level: {}'.format(str(round(ref_dBm, 1)))
+ self._logger.debug(infmsg)
+
+ def get_status(self, return_txt=False):
+ """Get current GSS7000 Status
+ Args:
+ return_txt: booling for determining the return results
+ Type, booling.
+ """
+ status_xml = self._query('NULL')
+ status = get_xml_text(status_xml, 'status')
+ if return_txt:
+ status_dict = {
+ '0': 'No Scenario loaded',
+ '1': 'Not completed loading a scenario',
+ '2': 'Idle, ready to run a scenario',
+ '3': 'Arming the scenario',
+ '4': 'Completed arming; or waiting for a command or'
+ 'trigger signal to start the scenario',
+ '5': 'Scenario running',
+ '6': 'Current scenario is paused.',
+ '7': 'Active scenario has stopped and has not been reset.'
+ 'Waiting for further commands.'
+ }
+ return status_dict.get(status)
+ else:
+ return int(status)
+
+ def set_power(self, power_level=-130):
+ """Set Power Level of GSS7000 Tx
+ Args:
+ power_level: transmit power level
+ Type, float.
+ Decimal, unit [dBm]
+
+ Raises:
+ GSS7000Error: raise when power level is not in [-170, -115] range.
+ """
+ if not -170 <= power_level <= -115:
+ errmsg = (f'"power_level" must be within [-170, -115], '
+ f'current input is {power_level}')
+ raise GSS7000Error(error=errmsg, command='set_power')
+
+ power_offset = power_level + 130
+ 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))
+ self._logger.debug(infmsg)
+
+ def power_lev_offset_cal(self, power_level=-130, sat='GPS', band='L1'):
+ """Convert target power level to power offset for GSS7000 power setting
+ Args:
+ power_level: transmit power level
+ Type, float.
+ Decimal, unit [dBm]
+ Default. -130
+ sat_system: to set power level for all Satellites
+ Type, str
+ Option 'GPS/GLO/GAL'
+ Type, str
+ freq_band: Frequency band to set the power level
+ Type, str
+ Option 'L1/L5/B1I/B1C/B2A/E5'
+ Default, '', assumed to be L1.
+ Return:
+ power_offset: The calculated power offset for setting GSS7000 GNSS target power.
+ """
+ gss7000_tx_pwr = {
+ 'GPS_L1': -130,
+ 'GPS_L5': -127.9,
+ 'GLONASS_F1': -131,
+ 'GALILEO_L1': -127,
+ 'GALILEO_E5': -122,
+ 'BEIDOU_B1I': -133,
+ 'BEIDOU_B1C': -130,
+ 'BEIDOU_B2A': -127,
+ 'QZSS_L1': -128.5,
+ 'QZSS_L5': -124.9,
+ 'IRNSS_L5': -130
+ }
+
+ sat_band = f'{sat}_{band}'
+ infmsg = f'Target satellite system and band: {sat_band}'
+ self._logger.debug(infmsg)
+ default_pwr_lev = gss7000_tx_pwr.get(sat_band, -130)
+ power_offset = power_level - default_pwr_lev
+ infmsg = (
+ f'Targer power: {power_level}; Default power: {default_pwr_lev};'
+ f' Power offset: {power_offset}')
+ self._logger.debug(infmsg)
+
+ return power_offset
+
+ def sat_band_convert(self, sat, band):
+ """Satellite system and operation band conversion and check.
+ Args:
+ sat: to set power level for all Satellites
+ Type, str
+ Option 'GPS/GLO/GAL/BDS'
+ Type, str
+ band: Frequency band to set the power level
+ Type, str
+ Option 'L1/L5/B1I/B1C/B2A/F1/E5'
+ Default, '', assumed to be L1.
+ """
+ sat_system_dict = {
+ 'GPS': 'GPS',
+ 'GLO': 'GLONASS',
+ 'GAL': 'GALILEO',
+ 'BDS': 'BEIDOU',
+ 'IRNSS': 'IRNSS',
+ 'ALL': 'GPS'
+ }
+ sat = sat_system_dict.get(sat, 'GPS')
+ if band == '':
+ infmsg = 'No band is set. Set to default band = L1'
+ self._logger.debug(infmsg)
+ band = 'L1'
+ if sat == '':
+ infmsg = 'No satellite system is set. Set to default sat = GPS'
+ self._logger.debug(infmsg)
+ sat = 'GPS'
+ sat_band = f'{sat}_{band}'
+ self._logger.debug(f'Current band: {sat_band}')
+ self._logger.debug(f'Capability: {self.capability}')
+ # Check if satellite standard and band are supported
+ # If not in support list, return GPS_L1 as default
+ if not sat_band in self.capability:
+ errmsg = (
+ 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('_'))
+
+ return sat_band_tp
+
+ def set_scenario_power(self,
+ power_level=-130,
+ sat_id='',
+ sat_system='',
+ freq_band='L1'):
+ """Set dynamic power for the running scenario.
+ Args:
+ power_level: transmit power level
+ Type, float.
+ Decimal, unit [dBm]
+ Default. -130
+ sat_id: set power level for specific satellite identifiers
+ Type, int.
+ sat_system: to set power level for all Satellites
+ 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'
+ Default, '', assumed to be L1.
+ Raises:
+ GSS7000Error: raise when power offset is not in [-49, -15] range.
+ """
+ band_dict = {
+ 'L1': 1,
+ 'L5': 2,
+ 'B2A': 2,
+ 'B1I': 1,
+ 'B1C': 1,
+ 'F1': 1,
+ 'E5': 2,
+ 'ALL': 3
+ }
+
+ # Convert and check satellite system and band
+ sat, band = self.sat_band_convert(sat_system, freq_band)
+ # Get freq band setting
+ band_cmd = band_dict.get(band, 1)
+
+ if not sat_id:
+ sat_id = 0
+ 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)
+
+ if not -49 <= power_offset <= 15:
+ errmsg = (f'"power_offset" must be within [-49, 15], '
+ f'current input is {power_offset}')
+ raise GSS7000Error(error=errmsg, command='set_power_offset')
+
+ 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/tests/controllers/bits_lib/bits_client_test.py b/acts/framework/tests/controllers/bits_lib/bits_client_test.py
index c4261d6..dda819d 100644
--- a/acts/framework/tests/controllers/bits_lib/bits_client_test.py
+++ b/acts/framework/tests/controllers/bits_lib/bits_client_test.py
@@ -17,6 +17,7 @@
from datetime import datetime
import unittest
+from acts.libs.proc import job
from acts.controllers.bits_lib import bits_client
from acts.controllers.bits_lib import bits_service_config
import mock
@@ -33,6 +34,18 @@
NON_MONSOONED_CONFIG = bits_service_config.BitsServiceConfig(
CONTROLLER_CONFIG_WITHOUT_MONSOON)
+KIBBLES_CONFIG = bits_service_config.BitsServiceConfig(
+ {
+ 'Kibbles': [{
+ 'board': 'board',
+ 'connector': 'connector',
+ 'serial': 'serial',
+ }],
+ },
+ kibble_bin='bin',
+ kibble_board_file='file.board',
+ virtual_metrics_file='file.vm')
+
class BitsClientTest(unittest.TestCase):
@@ -40,9 +53,25 @@
super().setUp()
self.mock_service = mock.Mock()
self.mock_service.port = '42'
- self.mock_active_collection = mock.Mock()
- self.mock_active_collection.name = 'my_active_collection'
- self.mock_active_collection.markers_buffer = []
+
+ @mock.patch('acts.libs.proc.job.run')
+ def test_execute_generic_command(self, mock_run):
+ mock_service = mock.Mock()
+ mock_service.port = '1337'
+ client = bits_client.BitsClient('bits.par', mock_service,
+ service_config=KIBBLES_CONFIG)
+
+ client.run_cmd('-i', '-am', '-not', '-a', '-teapot', timeout=12345)
+
+ expected_final_command = ['bits.par',
+ '--port',
+ '1337',
+ '-i',
+ '-am',
+ '-not',
+ '-a',
+ '-teapot']
+ mock_run.assert_called_with(expected_final_command, timeout=12345)
@mock.patch('acts.libs.proc.job.run')
def test_start_collection__without_monsoon__does_not_disconnect_monsoon(
@@ -51,7 +80,7 @@
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=NON_MONSOONED_CONFIG)
- client.start_collection()
+ client.start_collection('collection')
mock_run.assert_called()
args_list = mock_run.call_args_list
@@ -61,55 +90,57 @@
self.assertEqual(len(non_expected_call), 0,
'did not expect call with usb_disconnect')
- @mock.patch('acts.context.get_current_context')
@mock.patch('acts.libs.proc.job.run')
- def test_stop_collection__usb_not_automanaged__does_not_connect_monsoon(
- self,
- mock_run,
- mock_context):
- output_path = mock.MagicMock(return_value='out')
- mock_context.side_effect = lambda: output_path
+ def test_start_collection__frecuency_arg_gets_populated(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
- client.stop_collection()
+ client.start_collection('collection', default_sampling_rate=12345)
+
+ mock_run.assert_called()
+ args_list = mock_run.call_args_list
+ expected_calls = list(
+ filter(lambda call: '--time' in call.args[0], args_list))
+ self.assertEqual(len(expected_calls), 1, 'expected 1 calls with --time')
+ self.assertIn('--default_sampling_rate', expected_calls[0][0][0])
+ self.assertIn('12345', expected_calls[0][0][0])
+
+ @mock.patch('acts.libs.proc.job.run')
+ def test_start_collection__sampling_rate_defaults_to_1000(self, mock_run):
+ client = bits_client.BitsClient('bits.par', self.mock_service,
+ service_config=MONSOONED_CONFIG)
+
+ client.start_collection('collection')
+
+ mock_run.assert_called()
+ args_list = mock_run.call_args_list
+ expected_calls = list(
+ filter(lambda call: '--time' in call.args[0], args_list))
+ self.assertEqual(len(expected_calls), 1, 'expected 1 calls with --time')
+ self.assertIn('--default_sampling_rate', expected_calls[0][0][0])
+ self.assertIn('1000', expected_calls[0][0][0])
+
+ @mock.patch('acts.libs.proc.job.run')
+ def test_stop_collection__usb_not_automanaged__does_not_connect_monsoon(
+ self, mock_run):
+ client = bits_client.BitsClient('bits.par', self.mock_service,
+ service_config=MONSOONED_CONFIG)
+
+ client.stop_collection('collection')
mock_run.assert_called()
args_list = mock_run.call_args_list
non_expected_call = list(
filter(lambda call: 'usb_connect' in call.args[0], args_list))
- self.assertEquals(len(non_expected_call), 0,
- 'did not expect call with usb_connect')
+ self.assertEqual(len(non_expected_call), 0,
+ 'did not expect call with usb_connect')
- @mock.patch('acts.context.get_current_context')
@mock.patch('acts.libs.proc.job.run')
- def test_stop_collection__triggers_export(self, mock_run, mock_context):
- output_path = mock.MagicMock(return_value='out')
- mock_context.side_effect = lambda: output_path
+ def test_export_ignores_dataseries_gaps(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
- client.stop_collection()
-
- mock_run.assert_called()
- args_list = mock_run.call_args_list
- expected_call = list(
- filter(lambda call: '--export' in call.args[0], args_list))
- self.assertEqual(len(expected_call), 1,
- 'expected a call with --export')
-
- @mock.patch('acts.context.get_current_context')
- @mock.patch('acts.libs.proc.job.run')
- def test__export_ignores_dataseries_gaps(self, mock_run, mock_context):
- output_path = mock.MagicMock(return_value='out')
- mock_context.side_effect = lambda: output_path
- client = bits_client.BitsClient('bits.par', self.mock_service,
- service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
-
- client._export()
+ client.export('collection', '/path/a.7z.bits')
mock_run.assert_called()
args_list = mock_run.call_args_list
@@ -121,92 +152,107 @@
'expected a call with --ignore_gaps and --export')
self.assertIn('--ignore_gaps', expected_call[0].args[0])
- @mock.patch('acts.libs.proc.job.run')
- def test_add_marker(self, _):
+ def test_export_path_must_end_in_bits_file_extension(self):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
- client.add_marker(7133, 'my marker')
+ self.assertRaisesRegex(
+ bits_client.BitsClientError,
+ r'collections can only be exported to files ending in .7z.bits',
+ client.export, 'collection', '/path/')
- client._active_collection.add_marker.assert_called_with(7133,
- 'my marker')
-
- @mock.patch('acts.context.get_current_context')
@mock.patch('acts.libs.proc.job.run')
- def test_stop_collection__flushes_buffered_markers(self, mock_run,
- mock_context):
- output_path = mock.MagicMock(return_value='out')
- mock_context.side_effect = lambda: output_path
+ def test_export_as_csv(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- self.mock_active_collection.markers_buffer.append((3, 'tres'))
- self.mock_active_collection.markers_buffer.append((1, 'uno'))
- self.mock_active_collection.markers_buffer.append((2, 'dos'))
- client._active_collection = self.mock_active_collection
+ output_file = '/path/to/csv'
+ collection = 'collection'
- client.stop_collection()
+ client.export_as_csv([':mW', ':mV'], collection, output_file)
+
+ mock_run.assert_called()
+ cmd = mock_run.call_args_list[0].args[0]
+ self.assertIn(collection, cmd)
+ self.assertIn(output_file, cmd)
+ self.assertIn(':mW,:mV', cmd)
+ self.assertNotIn('--vm_file', cmd)
+ self.assertNotIn('default', cmd)
+
+ @mock.patch('acts.libs.proc.job.run')
+ def test_export_as_csv_with_virtual_metrics_file(self, mock_run):
+ output_file = '/path/to/csv'
+ collection = 'collection'
+ client = bits_client.BitsClient('bits.par', self.mock_service,
+ service_config=KIBBLES_CONFIG)
+
+ client.export_as_csv([':mW', ':mV'], collection, output_file)
+
+ mock_run.assert_called()
+ cmd = mock_run.call_args_list[0].args[0]
+ self.assertIn(collection, cmd)
+ self.assertIn(':mW,:mV', cmd)
+ self.assertIn('--vm_file', cmd)
+ self.assertIn('default', cmd)
+
+ @mock.patch('acts.libs.proc.job.run')
+ def test_add_markers(self, mock_run):
+ client = bits_client.BitsClient('bits.par', self.mock_service,
+ service_config=MONSOONED_CONFIG)
+
+ client.add_markers('collection', [(1, 'ein'),
+ (2, 'zwei'),
+ (3, 'drei')])
mock_run.assert_called()
args_list = mock_run.call_args_list
expected_calls = list(
filter(lambda call: '--log' in call.args[0], args_list))
- self.assertEqual(len(expected_calls), 3,
- 'expected 3 calls with --log')
+ self.assertEqual(len(expected_calls), 3, 'expected 3 calls with --log')
self.assertIn('--log_ts', expected_calls[0][0][0])
self.assertIn('1', expected_calls[0][0][0])
- self.assertIn('uno', expected_calls[0][0][0])
+ self.assertIn('ein', expected_calls[0][0][0])
+
self.assertIn('--log_ts', expected_calls[1][0][0])
self.assertIn('2', expected_calls[1][0][0])
- self.assertIn('dos', expected_calls[1][0][0])
+ self.assertIn('zwei', expected_calls[1][0][0])
+
self.assertIn('--log_ts', expected_calls[2][0][0])
self.assertIn('3', expected_calls[2][0][0])
- self.assertIn('tres', expected_calls[2][0][0])
- self.mock_active_collection.clear_markers_buffer.assert_called()
+ self.assertIn('drei', expected_calls[2][0][0])
- @mock.patch('acts.context.get_current_context')
@mock.patch('acts.libs.proc.job.run')
- def test_stop_collection__flushes_buffered_datetime_markers(self,
- mock_run,
- mock_context):
- output_path = mock.MagicMock(return_value='out')
- mock_context.side_effect = lambda: output_path
+ def test_add_markers_with_datetimes(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- self.mock_active_collection.markers_buffer.append(
- (datetime.utcfromtimestamp(3), 'tres'))
- self.mock_active_collection.markers_buffer.append(
- (datetime.utcfromtimestamp(1), 'uno'))
- self.mock_active_collection.markers_buffer.append(
- (datetime.utcfromtimestamp(2), 'dos'))
- client._active_collection = self.mock_active_collection
- client.stop_collection()
+ client.add_markers('collection',
+ [(datetime.utcfromtimestamp(1), 'ein'),
+ (2e9, 'zwei'),
+ (datetime.utcfromtimestamp(3), 'drei')])
mock_run.assert_called()
args_list = mock_run.call_args_list
expected_calls = list(
filter(lambda call: '--log' in call.args[0], args_list))
- self.assertEqual(len(expected_calls), 3,
- 'expected 3 calls with --log')
+ self.assertEqual(len(expected_calls), 3, 'expected 3 calls with --log')
self.assertIn('--log_ts', expected_calls[0][0][0])
self.assertIn(str(int(1e9)), expected_calls[0][0][0])
- self.assertIn('uno', expected_calls[0][0][0])
+ self.assertIn('ein', expected_calls[0][0][0])
+
self.assertIn('--log_ts', expected_calls[1][0][0])
self.assertIn(str(int(2e9)), expected_calls[1][0][0])
- self.assertIn('dos', expected_calls[1][0][0])
+ self.assertIn('zwei', expected_calls[1][0][0])
+
self.assertIn('--log_ts', expected_calls[2][0][0])
self.assertIn(str(int(3e9)), expected_calls[2][0][0])
- self.assertIn('tres', expected_calls[2][0][0])
- self.mock_active_collection.clear_markers_buffer.assert_called()
+ self.assertIn('drei', expected_calls[2][0][0])
@mock.patch('acts.libs.proc.job.run')
def test_get_metrics(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
- client.get_metrics(8888, 9999)
+ client.get_metrics('collection', 8888, 9999)
mock_run.assert_called()
args_list = mock_run.call_args_list
@@ -224,9 +270,9 @@
def test_get_metrics_with_datetime_markers(self, mock_run):
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=MONSOONED_CONFIG)
- client._active_collection = self.mock_active_collection
- client.get_metrics(datetime.utcfromtimestamp(1),
+ client.get_metrics('collection',
+ datetime.utcfromtimestamp(1),
datetime.utcfromtimestamp(2))
mock_run.assert_called()
@@ -247,7 +293,6 @@
service_config.has_virtual_metrics_file = True
client = bits_client.BitsClient('bits.par', self.mock_service,
service_config=service_config)
- client._active_collection = self.mock_active_collection
client.get_metrics(8888, 9999)
@@ -261,6 +306,21 @@
self.assertIn('--vm_file', expected_call[0][0][0])
self.assertIn('default', expected_call[0][0][0])
+ @mock.patch('acts.libs.proc.job.run',
+ return_value=job.Result(stdout=bytes('device', 'utf-8')))
+ def test_list_devices(self, mock_run):
+ service_config = mock.Mock()
+ client = bits_client.BitsClient('bits.par', self.mock_service,
+ service_config=service_config)
+
+ result = client.list_devices()
+
+ mock_run.assert_called()
+ cmd = mock_run.call_args_list[0].args[0]
+ self.assertIn('--list', cmd)
+ self.assertIn('devices', cmd)
+ self.assertEqual(result, 'device')
+
if __name__ == '__main__':
unittest.main()
diff --git a/acts/framework/tests/controllers/bits_test.py b/acts/framework/tests/controllers/bits_test.py
index e437bea..a7ea45c 100644
--- a/acts/framework/tests/controllers/bits_test.py
+++ b/acts/framework/tests/controllers/bits_test.py
@@ -3,6 +3,7 @@
# 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
#
diff --git a/acts/framework/tests/controllers/iperf_server_test.py b/acts/framework/tests/controllers/iperf_server_test.py
index b5d91a5..00f7da3 100644
--- a/acts/framework/tests/controllers/iperf_server_test.py
+++ b/acts/framework/tests/controllers/iperf_server_test.py
@@ -35,20 +35,15 @@
class IPerfServerModuleTest(unittest.TestCase):
"""Tests the acts.controllers.iperf_server module."""
-
def test_create_creates_local_iperf_server_with_int(self):
self.assertIsInstance(
- iperf_server.create([12345])[0],
- IPerfServer,
- 'create() failed to create IPerfServer for integer input.'
- )
+ iperf_server.create([12345])[0], IPerfServer,
+ 'create() failed to create IPerfServer for integer input.')
def test_create_creates_local_iperf_server_with_str(self):
self.assertIsInstance(
- iperf_server.create(['12345'])[0],
- IPerfServer,
- 'create() failed to create IPerfServer for integer input.'
- )
+ iperf_server.create(['12345'])[0], IPerfServer,
+ 'create() failed to create IPerfServer for integer input.')
def test_create_cannot_create_local_iperf_server_with_bad_str(self):
with self.assertRaises(ValueError):
@@ -57,39 +52,47 @@
@mock.patch('acts.controllers.iperf_server.utils')
def test_create_creates_server_over_ssh_with_ssh_config_and_port(self, _):
self.assertIsInstance(
- iperf_server.create([{'ssh_config': {'user': '', 'host': ''},
- 'port': ''}])[0],
- IPerfServerOverSsh,
- 'create() failed to create IPerfServerOverSsh for a valid config.'
- )
+ iperf_server.create([{
+ 'ssh_config': {
+ 'user': '',
+ 'host': ''
+ },
+ 'port': ''
+ }])[0], IPerfServerOverSsh,
+ 'create() failed to create IPerfServerOverSsh for a valid config.')
def test_create_creates_server_over_adb_with_proper_config(self):
self.assertIsInstance(
- iperf_server.create([{'AndroidDevice': '53R147', 'port': 0}])[0],
- IPerfServerOverAdb,
- 'create() failed to create IPerfServerOverAdb for a valid config.'
- )
+ iperf_server.create([{
+ 'AndroidDevice': '53R147',
+ 'port': 0
+ }])[0], IPerfServerOverAdb,
+ 'create() failed to create IPerfServerOverAdb for a valid config.')
def test_create_raises_value_error_on_bad_config_dict(self):
with self.assertRaises(ValueError):
- iperf_server.create([{'AndroidDevice': '53R147', 'ssh_config': {}}])
+ iperf_server.create([{
+ 'AndroidDevice': '53R147',
+ 'ssh_config': {}
+ }])
def test_get_port_from_ss_output_returns_correct_port_ipv4(self):
ss_output = ('tcp LISTEN 0 5 127.0.0.1:<PORT> *:*'
' users:(("cmd",pid=<PID>,fd=3))')
self.assertEqual(
- iperf_server._get_port_from_ss_output(ss_output, '<PID>'), '<PORT>')
+ iperf_server._get_port_from_ss_output(ss_output, '<PID>'),
+ '<PORT>')
def test_get_port_from_ss_output_returns_correct_port_ipv6(self):
ss_output = ('tcp LISTEN 0 5 ff:ff:ff:ff:ff:ff:<PORT> *:*'
' users:(("cmd",pid=<PID>,fd=3))')
self.assertEqual(
- iperf_server._get_port_from_ss_output(ss_output, '<PID>'), '<PORT>')
+ iperf_server._get_port_from_ss_output(ss_output, '<PID>'),
+ '<PORT>')
class IPerfServerBaseTest(unittest.TestCase):
"""Tests acts.controllers.iperf_server.IPerfServerBase."""
-
@mock.patch('os.makedirs')
def test_get_full_file_path_creates_parent_directory(self, mock_makedirs):
# Will never actually be created/used.
@@ -99,15 +102,11 @@
full_file_path = server._get_full_file_path()
- self.assertTrue(
- mock_makedirs.called,
- 'Did not attempt to create a directory.'
- )
+ self.assertTrue(mock_makedirs.called,
+ 'Did not attempt to create a directory.')
self.assertEqual(
- os.path.dirname(full_file_path),
- mock_makedirs.call_args[ARGS][0],
- 'The parent directory of the full file path was not created.'
- )
+ os.path.dirname(full_file_path), mock_makedirs.call_args[ARGS][0],
+ 'The parent directory of the full file path was not created.')
class IPerfServerTest(unittest.TestCase):
@@ -152,10 +151,8 @@
server.start()
self.assertEqual(
- server._current_log_file,
- MOCK_LOGFILE_PATH,
- 'The _current_log_file was not received from _get_full_file_path.'
- )
+ server._current_log_file, MOCK_LOGFILE_PATH,
+ 'The _current_log_file was not received from _get_full_file_path.')
@mock.patch('builtins.open')
@mock.patch('acts.controllers.iperf_server.subprocess')
@@ -167,16 +164,14 @@
log_file = server.stop()
- self.assertEqual(
- log_file,
- MOCK_LOGFILE_PATH,
- 'The _current_log_file was not returned by stop().'
- )
+ self.assertEqual(log_file, MOCK_LOGFILE_PATH,
+ 'The _current_log_file was not returned by stop().')
@mock.patch('builtins.open')
@mock.patch('acts.controllers.iperf_server.subprocess')
@mock.patch('acts.controllers.iperf_server.job')
- def test_start_does_not_run_two_concurrent_processes(self, start_proc, _, __):
+ def test_start_does_not_run_two_concurrent_processes(
+ self, start_proc, _, __):
server = IPerfServer('port')
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server._iperf_process = mock.Mock()
@@ -185,8 +180,7 @@
self.assertFalse(
start_proc.called,
- 'start() should not begin a second process if another is running.'
- )
+ 'start() should not begin a second process if another is running.')
@mock.patch('acts.utils.stop_standing_subprocess')
def test_stop_exits_early_if_no_process_has_started(self, stop_proc):
@@ -198,8 +192,7 @@
self.assertFalse(
stop_proc.called,
- 'stop() should not kill a process if no process is running.'
- )
+ 'stop() should not kill a process if no process is running.')
class IPerfServerOverSshTest(unittest.TestCase):
@@ -212,6 +205,7 @@
"""Tests calling start() without calling stop() makes started True."""
server = IPerfServerOverSsh(*self.INIT_ARGS)
server._ssh_session = mock.Mock()
+ server._cleanup_iperf_port = mock.Mock()
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server.start()
@@ -224,6 +218,7 @@
"""Tests calling start() without calling stop() makes started True."""
server = IPerfServerOverSsh(*self.INIT_ARGS)
server._ssh_session = mock.Mock()
+ server._cleanup_iperf_port = mock.Mock()
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server.start()
@@ -236,21 +231,20 @@
def test_stop_returns_expected_log_file(self, _, __):
server = IPerfServerOverSsh(*self.INIT_ARGS)
server._ssh_session = mock.Mock()
+ server._cleanup_iperf_port = mock.Mock()
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server._iperf_pid = mock.Mock()
log_file = server.stop()
- self.assertEqual(
- log_file,
- MOCK_LOGFILE_PATH,
- 'The expected log file was not returned by stop().'
- )
+ self.assertEqual(log_file, MOCK_LOGFILE_PATH,
+ 'The expected log file was not returned by stop().')
@mock.patch('acts.controllers.iperf_server.connection')
def test_start_does_not_run_two_concurrent_processes(self, _):
server = IPerfServerOverSsh(*self.INIT_ARGS)
server._ssh_session = mock.Mock()
+ server._cleanup_iperf_port = mock.Mock()
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server._iperf_pid = mock.Mock()
@@ -258,14 +252,14 @@
self.assertFalse(
server._ssh_session.run_async.called,
- 'start() should not begin a second process if another is running.'
- )
+ 'start() should not begin a second process if another is running.')
@mock.patch('acts.utils.stop_standing_subprocess')
@mock.patch('acts.controllers.iperf_server.connection')
def test_stop_exits_early_if_no_process_has_started(self, _, __):
server = IPerfServerOverSsh(*self.INIT_ARGS)
server._ssh_session = mock.Mock()
+ server._cleanup_iperf_port = mock.Mock()
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server._iperf_pid = None
@@ -273,8 +267,7 @@
self.assertFalse(
server._ssh_session.run_async.called,
- 'stop() should not kill a process if no process is running.'
- )
+ 'stop() should not kill a process if no process is running.')
class IPerfServerOverAdbTest(unittest.TestCase):
@@ -320,11 +313,8 @@
log_file = server.stop()
- self.assertEqual(
- log_file,
- MOCK_LOGFILE_PATH,
- 'The expected log file was not returned by stop().'
- )
+ self.assertEqual(log_file, MOCK_LOGFILE_PATH,
+ 'The expected log file was not returned by stop().')
@mock.patch(ANDROID_DEVICE_PROP)
def test_start_does_not_run_two_concurrent_processes(self, android_device):
@@ -336,14 +326,13 @@
self.assertFalse(
android_device.adb.shell_nb.called,
- 'start() should not begin a second process if another is running.'
- )
+ 'start() should not begin a second process if another is running.')
@mock.patch('acts.libs.proc.job.run')
@mock.patch('builtins.open')
@mock.patch(ANDROID_DEVICE_PROP)
- def test_stop_exits_early_if_no_process_has_started(self, android_device, _,
- __):
+ def test_stop_exits_early_if_no_process_has_started(
+ self, android_device, _, __):
server = IPerfServerOverAdb('53R147', 'PORT')
server._get_full_file_path = lambda _: MOCK_LOGFILE_PATH
server._iperf_pid = None
@@ -352,8 +341,7 @@
self.assertFalse(
android_device.adb.shell_nb.called,
- 'stop() should not kill a process if no process is running.'
- )
+ 'stop() should not kill a process if no process is running.')
if __name__ == '__main__':
diff --git a/acts/framework/tests/controllers/power_metrics_test.py b/acts/framework/tests/controllers/power_metrics_test.py
index 1533998..a14ca8d 100644
--- a/acts/framework/tests/controllers/power_metrics_test.py
+++ b/acts/framework/tests/controllers/power_metrics_test.py
@@ -24,9 +24,9 @@
from acts.controllers.power_metrics import CURRENT
from acts.controllers.power_metrics import END_TIMESTAMP
from acts.controllers.power_metrics import HOUR
+from acts.controllers.power_metrics import Metric
from acts.controllers.power_metrics import MILLIAMP
from acts.controllers.power_metrics import MINUTE
-from acts.controllers.power_metrics import Metric
from acts.controllers.power_metrics import PowerMetrics
from acts.controllers.power_metrics import START_TIMESTAMP
from acts.controllers.power_metrics import TIME
@@ -137,20 +137,34 @@
"""Test that given test timestamps, a power metric is generated from
a subset of samples corresponding to the test."""
timestamps = {'sample_test': {START_TIMESTAMP: 3500,
- END_TIMESTAMP: 8500}}
+ END_TIMESTAMP: 8500}}
mock_power_metric = mock.Mock()
mock_power_metric_type.side_effect = lambda v: mock_power_metric
- metrics = power_metrics.generate_test_metrics(self.RAW_DATA,
- timestamps=timestamps,
- voltage=self.VOLTAGE)
+ power_metrics.generate_test_metrics(self.RAW_DATA,
+ timestamps=timestamps,
+ voltage=self.VOLTAGE)
self.assertEqual(mock_power_metric.update_metrics.call_count, 5)
+ def test_incomplete_timestamps_are_ignored(self):
+ """Test that given incomplete timestamps, a power metric is generated from
+ a subset of samples corresponding to the test."""
+ sample_test = 'sample_test'
+ test_end = 13500
+ test_timestamps = {sample_test: {
+ END_TIMESTAMP: test_end}}
+ # no error expected
+ metrics = (
+ power_metrics.generate_test_metrics(self.RAW_DATA,
+ timestamps=test_timestamps,
+ voltage=self.VOLTAGE))
+
+
def test_numeric_metrics(self):
"""Test that the numeric metrics have correct values."""
timestamps = {'sample_test': {START_TIMESTAMP: 0,
- END_TIMESTAMP: 10000}}
+ END_TIMESTAMP: 10000}}
metrics = power_metrics.generate_test_metrics(self.RAW_DATA,
timestamps=timestamps,
voltage=self.VOLTAGE)
diff --git a/acts_tests/acts_contrib/test_utils/bt/A2dpBaseTest.py b/acts_tests/acts_contrib/test_utils/bt/A2dpBaseTest.py
index e943083..36acdfd 100644
--- a/acts_tests/acts_contrib/test_utils/bt/A2dpBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/bt/A2dpBaseTest.py
@@ -16,14 +16,21 @@
"""Stream music through connected device from phone test implementation."""
import acts
import os
+import pandas as pd
import shutil
import time
import acts_contrib.test_utils.coex.audio_test_utils as atu
import acts_contrib.test_utils.bt.bt_test_utils as btutils
from acts import asserts
+from acts_contrib.test_utils.bt import bt_constants
+from acts_contrib.test_utils.bt import BtEnum
from acts_contrib.test_utils.abstract_devices.bluetooth_handsfree_abstract_device import BluetoothHandsfreeAbstractDeviceFactory as bt_factory
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.loggers import bluetooth_metric_logger as log
+from acts.signals import TestPass, TestError
PHONE_MUSIC_FILE_DIRECTORY = '/sdcard/Music'
INIT_ATTEN = 0
@@ -44,12 +51,15 @@
def setup_class(self):
super().setup_class()
+ self.bt_logger = log.BluetoothMetricLogger.for_test_case()
self.dut = self.android_devices[0]
- req_params = ['audio_params', 'music_files']
+ req_params = ['audio_params', 'music_files', 'system_path_loss']
+ opt_params = ['bugreport']
#'audio_params' is a dict, contains the audio device type, audio streaming
#settings such as volumn, duration, audio recording parameters such as
#channel, sampling rate/width, and thdn parameters for audio processing
self.unpack_userparams(req_params)
+ self.unpack_userparams(opt_params, bugreport=None)
# Find music file and push it to the dut
music_src = self.music_files[0]
music_dest = PHONE_MUSIC_FILE_DIRECTORY
@@ -113,6 +123,11 @@
self.bt_device.power_off()
btutils.disable_bluetooth(self.dut.droid)
+ def on_pass(self, test_name, begin_time):
+
+ if hasattr(self, 'bugreport') and self.bugreport == 1:
+ self._take_bug_report(test_name, begin_time)
+
def play_and_record_audio(self, duration):
"""Play and record audio for a set duration.
@@ -135,27 +150,45 @@
asserts.assert_true(audio_captured, 'Audio not recorded')
return audio_captured
- def _get_bt_link_metrics(self):
+ def _get_bt_link_metrics(self, tag=''):
"""Get bt link metrics such as rssi and tx pwls.
Returns:
- rssi_master: master rssi
- pwl_master: master tx pwl
- rssi_slave: slave rssi
+ master_metrics_list: list of metrics of central device
+ slave_metrics_list: list of metric of peripheral device
"""
+ self.raw_bt_metrics_path = os.path.join(self.log_path,
+ 'BT_Raw_Metrics')
self.media.play()
# Get master rssi and power level
- rssi_master = btutils.get_bt_metric(self.dut)['rssi']
- pwl_master = btutils.get_bt_metric(self.dut)['pwlv']
- # Get slave rssi if possible
+ process_data_dict = btutils.get_bt_metric(
+ self.dut, tag=tag, log_path=self.raw_bt_metrics_path)
+ rssi_master = process_data_dict.get('rssi')
+ pwl_master = process_data_dict.get('pwlv')
+ rssi_c0_master = process_data_dict.get('rssi_c0')
+ rssi_c1_master = process_data_dict.get('rssi_c1')
+ txpw_c0_master = process_data_dict.get('txpw_c0')
+ txpw_c1_master = process_data_dict.get('txpw_c1')
+ bftx_master = process_data_dict.get('bftx')
+ divtx_master = process_data_dict.get('divtx')
+
if isinstance(self.bt_device_controller,
acts.controllers.android_device.AndroidDevice):
- rssi_slave = btutils.get_bt_rssi(self.bt_device_controller)
+ rssi_slave = btutils.get_bt_rssi(self.bt_device_controller,
+ tag=tag,
+ log_path=self.raw_bt_metrics_path)
else:
rssi_slave = None
self.media.stop()
- return [rssi_master, pwl_master, rssi_slave]
+
+ master_metrics_list = [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ]
+ slave_metrics_list = [rssi_slave]
+
+ return master_metrics_list, slave_metrics_list
def run_thdn_analysis(self, audio_captured, tag):
"""Calculate Total Harmonic Distortion plus Noise for latest recording.
@@ -205,3 +238,208 @@
else:
self.log.info('%i anomalies detected.' % num_anom)
return anom
+
+ def generate_proto(self, data_points, codec_type, sample_rate,
+ bits_per_sample, channel_mode):
+ """Generate a results protobuf.
+
+ Args:
+ data_points: list of dicts representing info to go into
+ AudioTestDataPoint protobuffer message.
+ codec_type: The codec type config to store in the proto.
+ sample_rate: The sample rate config to store in the proto.
+ bits_per_sample: The bits per sample config to store in the proto.
+ channel_mode: The channel mode config to store in the proto.
+ Returns:
+ dict: Dictionary with key 'proto' mapping to serialized protobuf,
+ 'proto_ascii' mapping to human readable protobuf info, and 'test'
+ mapping to the test class name that generated the results.
+ """
+
+ # Populate protobuf
+ test_case_proto = self.bt_logger.proto_module.BluetoothAudioTestResult(
+ )
+
+ for data_point in data_points:
+ audio_data_proto = test_case_proto.data_points.add()
+ log.recursive_assign(audio_data_proto, data_point)
+
+ codec_proto = test_case_proto.a2dp_codec_config
+ codec_proto.codec_type = bt_constants.codec_types[codec_type]
+ codec_proto.sample_rate = int(sample_rate)
+ codec_proto.bits_per_sample = int(bits_per_sample)
+ codec_proto.channel_mode = bt_constants.channel_modes[channel_mode]
+
+ self.bt_logger.add_config_data_to_proto(test_case_proto, self.dut,
+ self.bt_device)
+
+ self.bt_logger.add_proto_to_results(test_case_proto,
+ self.__class__.__name__)
+
+ proto_dict = self.bt_logger.get_proto_dict(self.__class__.__name__,
+ test_case_proto)
+ del proto_dict["proto_ascii"]
+ return proto_dict
+
+ def set_test_atten(self, atten):
+ """Set the attenuation(s) for current test condition.
+
+ """
+ if hasattr(self, 'dual_chain') and self.dual_chain == 1:
+ ramp_attenuation(self.atten_c0,
+ atten,
+ attenuation_step_max=2,
+ time_wait_in_between=1)
+ self.log.info('Set Chain 0 attenuation to %d dB', atten)
+ ramp_attenuation(self.atten_c1,
+ atten + self.gain_mismatch,
+ attenuation_step_max=2,
+ time_wait_in_between=1)
+ self.log.info('Set Chain 1 attenuation to %d dB',
+ atten + self.gain_mismatch)
+ else:
+ ramp_attenuation(self.attenuator, atten)
+ self.log.info('Set attenuation to %d dB', atten)
+
+ def run_a2dp_to_max_range(self, codec_config):
+ attenuation_range = range(self.attenuation_vector['start'],
+ self.attenuation_vector['stop'] + 1,
+ self.attenuation_vector['step'])
+
+ data_points = []
+ self.file_output = os.path.join(
+ self.log_path, '{}.csv'.format(self.current_test_name))
+
+ # Set Codec if needed
+ current_codec = self.dut.droid.bluetoothA2dpGetCurrentCodecConfig()
+ current_codec_type = BtEnum.BluetoothA2dpCodecType(
+ current_codec['codecType']).name
+ if current_codec_type != codec_config['codec_type']:
+ codec_set = btutils.set_bluetooth_codec(self.dut, **codec_config)
+ asserts.assert_true(codec_set, 'Codec configuration failed.')
+ else:
+ self.log.info('Current codec is {}, no need to change'.format(
+ current_codec_type))
+
+ #loop RSSI with the same codec setting
+ for atten in attenuation_range:
+ self.media.play()
+ self.set_test_atten(atten)
+
+ tag = 'codec_{}_attenuation_{}dB_'.format(
+ codec_config['codec_type'], atten)
+ recorded_file = self.play_and_record_audio(
+ self.audio_params['duration'])
+ thdns = self.run_thdn_analysis(recorded_file, tag)
+
+ # Collect Metrics for dashboard
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics(tag)
+
+ data_point = {
+ 'attenuation_db':
+ int(self.attenuator.get_atten()),
+ 'pathloss':
+ atten + self.system_path_loss,
+ 'rssi_primary':
+ rssi_master.get(self.dut.serial, -127),
+ 'tx_power_level_master':
+ pwl_master.get(self.dut.serial, -127),
+ 'rssi_secondary':
+ rssi_slave.get(self.bt_device_controller.serial, -127),
+ 'rssi_c0_dut':
+ rssi_c0_master.get(self.dut.serial, -127),
+ 'rssi_c1_dut':
+ rssi_c1_master.get(self.dut.serial, -127),
+ 'txpw_c0_dut':
+ txpw_c0_master.get(self.dut.serial, -127),
+ 'txpw_c1_dut':
+ txpw_c1_master.get(self.dut.serial, -127),
+ 'bftx_state':
+ bftx_master.get(self.dut.serial, -127),
+ 'divtx_state':
+ divtx_master.get(self.dut.serial, -127),
+ 'total_harmonic_distortion_plus_noise_percent':
+ thdns[0] * 100
+ }
+ self.log.info(data_point)
+ # 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_label': 'Pathloss (dBm)',
+ 'primary_y_label': 'RSSI (dBm)',
+ 'x_column': 'pathloss',
+ 'y_column': 'rssi_primary',
+ 'legend': 'DUT RSSI (dBm)',
+ 'marker': 'circle_x',
+ 'y_axis': 'default'
+ },
+ 'line_two': {
+ 'x_column': 'pathloss',
+ 'y_column': 'rssi_secondary',
+ 'legend': 'Remote device RSSI (dBm)',
+ 'marker': 'hex',
+ 'y_axis': 'default'
+ },
+ 'line_three': {
+ 'x_column': 'pathloss',
+ 'y_column': 'tx_power_level_master',
+ 'legend': 'DUT TX Power (dBm)',
+ 'marker': 'hex',
+ 'y_axis': 'secondary'
+ }
+ }
+
+ # Check thdn for glitches, stop if max range reached
+ if thdns[0] == 0:
+ proto_dict = self.generate_proto(data_points, **codec_config)
+ A2dpRange_df = pd.DataFrame(data_points)
+ A2dpRange_df.to_csv(self.file_output, index=False)
+ plot_graph(A2dpRange_df,
+ plot_data,
+ bokeh_data,
+ secondary_y_label='DUT TX Power')
+ raise TestError(
+ 'Music play/recording is not working properly or Connection has lost'
+ )
+
+ data_points.append(data_point)
+ A2dpRange_df = pd.DataFrame(data_points)
+
+ for thdn in thdns:
+ if thdn >= self.audio_params['thdn_threshold']:
+ self.log.info(
+ 'Max range at attenuation {} dB'.format(atten))
+ self.log.info('DUT rssi {} dBm, DUT tx power level {}, '
+ 'Remote rssi {} dBm'.format(
+ rssi_master, pwl_master, rssi_slave))
+ proto_dict = self.generate_proto(data_points,
+ **codec_config)
+ A2dpRange_df.to_csv(self.file_output, index=False)
+ plot_graph(A2dpRange_df,
+ plot_data,
+ bokeh_data,
+ secondary_y_label='DUT TX Power')
+ return True
+ raise TestPass('Max range reached and move to next codec',
+ extras=proto_dict)
+ # Save Data points to csv
+ A2dpRange_df.to_csv(self.file_output, index=False)
+ # Plot graph
+ plot_graph(A2dpRange_df,
+ plot_data,
+ bokeh_data,
+ secondary_y_label='DUT TX Power')
+ proto_dict = self.generate_proto(data_points, **codec_config)
+ return True
+ raise TestPass('Could not reach max range, need extra attenuation.',
+ extras=proto_dict)
diff --git a/acts_tests/acts_contrib/test_utils/bt/BtInterferenceBaseTest.py b/acts_tests/acts_contrib/test_utils/bt/BtInterferenceBaseTest.py
index 3c49bee..99ca5da 100644
--- a/acts_tests/acts_contrib/test_utils/bt/BtInterferenceBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/bt/BtInterferenceBaseTest.py
@@ -18,7 +18,9 @@
import json
import math
+import random
import time
+import logging
import acts.controllers.iperf_client as ipc
import acts.controllers.iperf_server as ipf
import acts_contrib.test_utils.bt.bt_test_utils as btutils
@@ -44,7 +46,7 @@
ap: access point object
bandwidth: bandwidth of the WiFi network to be setup
Returns:
- self.brconfigs: dict for bridge interface configs
+ brconfigs: dict for bridge interface configs
"""
wutils.wifi_toggle_state(dut, True)
brconfigs = wputils.ap_setup(ap, network, bandwidth=bandwidth)
@@ -103,6 +105,52 @@
return throughput
+def locate_interference_pair_by_channel(wifi_int_pairs, interference_channels):
+ """Function to find which attenautor to set based on channel info
+ Args:
+ interference_channels: list of interference channels
+ Return:
+ interference_pair_indices: list of indices for interference pair
+ in wifi_int_pairs
+ """
+ interference_pair_indices = []
+ for chan in interference_channels:
+ for i in range(len(wifi_int_pairs)):
+ if wifi_int_pairs[i].channel == chan:
+ interference_pair_indices.append(i)
+ return interference_pair_indices
+
+
+def inject_static_wifi_interference(wifi_int_pairs, interference_level,
+ channels):
+ """Function to inject wifi interference to bt link and read rssi.
+
+ Interference of IPERF traffic is always running, by setting attenuation,
+ the gate is opened to release the interference to the setup.
+ Args:
+ interference_level: the signal strength of wifi interference, use
+ attenuation level to represent this
+ channels: wifi channels where interference will
+ be injected, list
+ """
+ all_pair = range(len(wifi_int_pairs))
+ interference_pair_indices = locate_interference_pair_by_channel(
+ wifi_int_pairs, channels)
+ inactive_interference_pairs_indices = [
+ item for item in all_pair if item not in interference_pair_indices
+ ]
+ logging.info('WiFi interference at {} and inactive channels at {}'.format(
+ interference_pair_indices, inactive_interference_pairs_indices))
+ for i in interference_pair_indices:
+ wifi_int_pairs[i].attenuator.set_atten(interference_level)
+ logging.info('Set attenuation {} dB on attenuator {}'.format(
+ wifi_int_pairs[i].attenuator.get_atten(), i + 1))
+ for i in inactive_interference_pairs_indices:
+ wifi_int_pairs[i].attenuator.set_atten(MAX_ATTENUATION)
+ logging.info('Set attenuation {} dB on attenuator {}'.format(
+ wifi_int_pairs[i].attenuator.get_atten(), i + 1))
+
+
class BtInterferenceBaseTest(A2dpBaseTest):
def __init__(self, configs):
super().__init__(configs)
@@ -163,7 +211,6 @@
obj.iperf_server.port))
obj.iperf_server.stop()
self.log.info('Stop IPERF process on {}'.format(obj.dut.serial))
- obj.dut.adb.shell('pkill -9 iperf3')
#only for glinux machine
# wputils.bring_down_interface(obj.ether_int.interface)
obj.attenuator.set_atten(MAX_ATTENUATION)
@@ -172,7 +219,6 @@
def teardown_test(self):
super().teardown_test()
-
for obj in self.wifi_int_pairs:
obj.attenuator.set_atten(MAX_ATTENUATION)
diff --git a/acts_tests/acts_contrib/test_utils/bt/ble_performance_test_utils.py b/acts_tests/acts_contrib/test_utils/bt/ble_performance_test_utils.py
index 394e962..01231d3 100644
--- a/acts_tests/acts_contrib/test_utils/bt/ble_performance_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/bt/ble_performance_test_utils.py
@@ -16,19 +16,25 @@
import logging
import time
+import datetime
import statistics
-from queue import Empty
-from concurrent.futures import ThreadPoolExecutor
-
+import os
+from acts_contrib.test_utils.bt.bt_constants import advertising_set_started
+import acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure as bokeh_figure
+from acts_contrib.test_utils.bt.bt_constants import ble_scan_settings_phys
+from acts_contrib.test_utils.bt.bt_constants import ble_scan_settings_modes
from acts_contrib.test_utils.bt.bt_gatt_utils import close_gatt_client
from acts_contrib.test_utils.bt.bt_coc_test_utils import do_multi_connection_throughput
from acts_contrib.test_utils.bt.bt_gatt_utils import disconnect_gatt_connection
+from queue import Empty
from acts_contrib.test_utils.bt.bt_constants import gatt_cb_err
from acts_contrib.test_utils.bt.bt_constants import gatt_cb_strings
from acts_contrib.test_utils.bt.bt_constants import l2cap_coc_header_size
from acts_contrib.test_utils.bt.bt_gatt_utils import GattTestUtilsError
+from acts_contrib.test_utils.bt.bt_test_utils import generate_ble_scan_objects
from acts_contrib.test_utils.bt.bt_coc_test_utils import orchestrate_coc_connection
from acts_contrib.test_utils.bt.bt_gatt_utils import orchestrate_gatt_connection
+from concurrent.futures import ThreadPoolExecutor
default_event_timeout = 10
rssi_read_duration = 25
@@ -91,6 +97,43 @@
return ble_rssi
+def read_ble_scan_rssi(client_ad, scan_callback, rssi_read_duration=30):
+ """Function to Read BLE RSSI of the remote BLE device.
+ Args:
+ client_ad: the Android device performing the connection.
+ scan_callback: the scan callback of the server
+ Returns:
+ ble_rssi: RSSI value of the remote BLE device
+ raw_rssi: RSSI list of remote BLE device
+ """
+ raw_rssi = []
+ timestamp = []
+ end_time = time.time() + rssi_read_duration
+ logging.info("Reading BLE Scan RSSI for {} sec".format(rssi_read_duration))
+ while time.time() < end_time:
+ expected_event = gatt_cb_strings['rd_remote_ble_rssi'].format(
+ scan_callback)
+ try:
+ event = client_ad.ed.pop_event(expected_event,
+ default_event_timeout)
+ except Empty:
+ logging.error(
+ gatt_cb_err['rd_remote_rssi_err'].format(expected_event))
+ return False
+ rssi_value = event['data']['Result']['rssi']
+ epoch_time = event['time']
+ d = datetime.datetime.fromtimestamp(epoch_time / 1000)
+ tstamp = d.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+ timestamp.append(tstamp)
+ raw_rssi.append(rssi_value)
+ logging.debug("First & Last reading of RSSI :{:03d} & {:03d}".format(
+ raw_rssi[0], raw_rssi[-1]))
+ ble_rssi = statistics.mean(raw_rssi)
+ ble_rssi = round(ble_rssi, 2)
+
+ return ble_rssi, raw_rssi, timestamp
+
+
def ble_coc_connection(client_ad, server_ad):
"""Sets up the CoC connection between two Android devices.
@@ -104,10 +147,10 @@
client connection ID: Client connection ID
and server connection ID : server connection ID
"""
- #secured_conn: True if using secured connection
- #le_connection_interval: LE Connection interval. 0 means use default.
- #buffer_size : is the number of bytes per L2CAP data buffer
- #le_tx_data_length: LE Data Length used by BT Controller to transmit.
+ # secured_conn: True if using secured connection
+ # le_connection_interval: LE Connection interval. 0 means use default.
+ # buffer_size : is the number of bytes per L2CAP data buffer
+ # le_tx_data_length: LE Data Length used by BT Controller to transmit.
is_secured = False
le_connection_interval = 30
buffer_size = 240
@@ -134,7 +177,9 @@
return True, gatt_callback, gatt_server, bluetooth_gatt, client_conn_id
-def run_ble_throughput(server_ad, client_conn_id, client_ad,
+def run_ble_throughput(server_ad,
+ client_conn_id,
+ client_ad,
num_iterations=30):
"""Function to measure Throughput from one client to one-or-many servers
@@ -208,3 +253,76 @@
logging.error(err)
return False
return True
+
+
+def plot_graph(df, plot_data, bokeh_data, secondary_y_label=None):
+ """ Plotting for generating bokeh figure
+
+ Args:
+ df: Summary of results contains attenuation, DUT RSSI, remote RSSI and Tx Power
+ plot_data: plot_data for adding line to existing BokehFigure
+ bokeh_data: bokeh data for generating BokehFigure
+ secondary_y_label : label for secondary y axis , None if not available
+ """
+ plot = bokeh_figure.BokehFigure(
+ title='{}'.format(bokeh_data['current_test_name']),
+ x_label=bokeh_data['x_label'],
+ primary_y_label=bokeh_data['primary_y_label'],
+ secondary_y_label=secondary_y_label,
+ axis_label_size='16pt',
+ legend_label_size='16pt',
+ axis_tick_label_size='16pt',
+ sizing_mode='stretch_both')
+
+ for data in plot_data:
+ plot.add_line(df[plot_data[data].get('x_column')],
+ df[plot_data[data].get('y_column')],
+ legend=plot_data[data].get('legend'),
+ marker=plot_data[data].get('marker'),
+ y_axis=plot_data[data].get('y_axis'))
+
+ results_file_path = os.path.join(
+ bokeh_data['log_path'],
+ '{}.html'.format(bokeh_data['current_test_name']))
+ plot.generate_figure()
+ bokeh_figure.BokehFigure.save_figures([plot], results_file_path)
+
+
+def start_advertising_and_scanning(client_ad, server_ad, Legacymode=True):
+ """Function to start bt5 advertisement.
+
+ Args:
+ client_ad: the Android device performing the scanning.
+ server_ad: the Android device performing the bt advertising
+ Legacymode: True for Legacy advertising mode, false for bt5 advertising mode
+ Returns:
+ adv_callback: the advertising callback
+ scan_callback: the scan_callback
+ """
+ adv_callback = server_ad.droid.bleAdvSetGenCallback()
+ adv_data = {
+ "includeDeviceName": True,
+ }
+ server_ad.droid.bleAdvSetStartAdvertisingSet(
+ {
+ "connectable": False,
+ "legacyMode": Legacymode,
+ "primaryPhy": "PHY_LE_1M",
+ "secondaryPhy": "PHY_LE_1M",
+ "interval": 320
+ }, adv_data, None, None, None, 0, 0, adv_callback)
+ server_ad.ed.pop_event(advertising_set_started.format(adv_callback),
+ default_event_timeout)
+ logging.info("Bt5 Advertiser Started Successfully")
+ client_ad.droid.bleSetScanSettingsLegacy(False)
+ client_ad.droid.bleSetScanSettingsScanMode(
+ ble_scan_settings_modes['low_latency'])
+ client_ad.droid.bleSetScanSettingsPhy(ble_scan_settings_phys['1m'])
+
+ filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
+ client_ad.droid)
+ adv_device_name = server_ad.droid.bluetoothGetLocalName()
+ client_ad.droid.bleSetScanFilterDeviceName(adv_device_name)
+ client_ad.droid.bleBuildScanFilter(filter_list)
+ client_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback)
+ return adv_callback, scan_callback
diff --git a/acts_tests/acts_contrib/test_utils/bt/bt_constants.py b/acts_tests/acts_contrib/test_utils/bt/bt_constants.py
index 71cebd7..ffb56b4 100644
--- a/acts_tests/acts_contrib/test_utils/bt/bt_constants.py
+++ b/acts_tests/acts_contrib/test_utils/bt/bt_constants.py
@@ -348,6 +348,7 @@
"desc_read": "GattConnect{}onDescriptorRead",
"desc_read_req": "GattServer{}onDescriptorReadRequest",
"rd_remote_rssi": "GattConnect{}onReadRemoteRssi",
+ "rd_remote_ble_rssi": "BleScan{}onScanResults",
"gatt_serv_disc": "GattConnect{}onServicesDiscovered",
"serv_added": "GattServer{}onServiceAdded",
"mtu_changed": "GattConnect{}onMtuChanged",
diff --git a/acts_tests/acts_contrib/test_utils/bt/bt_test_utils.py b/acts_tests/acts_contrib/test_utils/bt/bt_test_utils.py
index eeb72d3..ba66535 100644
--- a/acts_tests/acts_contrib/test_utils/bt/bt_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/bt/bt_test_utils.py
@@ -21,9 +21,12 @@
import string
import threading
import time
+try:
+ import pandas as pd
+except ModuleNotFoundError:
+ pass
from queue import Empty
from subprocess import call
-
from acts import asserts
from acts_contrib.test_utils.bt.bt_constants import adv_fail
from acts_contrib.test_utils.bt.bt_constants import adv_succ
@@ -105,8 +108,7 @@
ad.ed.pop_event(expected_bluetooth_on_event_name,
bt_default_timeout)
except Empty:
- ad.log.info(
- "Failed to toggle Bluetooth on(no broadcast received).")
+ ad.log.info("Failed to toggle Bluetooth on(no broadcast received).")
# Try one more time to poke at the actual state.
if ad.droid.bluetoothCheckState():
ad.log.info(".. actual state is ON")
@@ -230,9 +232,7 @@
while not connected and (time.time() - start_time < timeout):
bonded_info = android.droid.bluetoothGetBondedDevices()
connected_info = android.droid.bluetoothGetConnectedDevices()
- if headset.mac_address not in [
- info["address"] for info in bonded_info
- ]:
+ if headset.mac_address not in [info["address"] for info in bonded_info]:
# Use SL4A to pair and connect with headset.
headset.enter_pairing_mode()
android.droid.bluetoothDiscoverAndBond(headset_mac_address)
@@ -251,6 +251,7 @@
log.info('Devices connected after pair attempt: %s' % connected)
return connected
+
def connect_pri_to_sec(pri_ad, sec_ad, profiles_set, attempts=2):
"""Connects pri droid to secondary droid.
@@ -312,34 +313,33 @@
# Now try to connect them, the following call will try to initiate all
# connections.
- pri_ad.droid.bluetoothConnectBonded(
- sec_ad.droid.bluetoothGetLocalAddress())
+ pri_ad.droid.bluetoothConnectBonded(sec_ad.droid.bluetoothGetLocalAddress())
end_time = time.time() + 10
profile_connected = set()
sec_addr = sec_ad.droid.bluetoothGetLocalAddress()
pri_ad.log.info("Profiles to be connected {}".format(profiles_set))
# First use APIs to check profile connection state
- while (time.time() < end_time
- and not profile_connected.issuperset(profiles_set)):
- if (bt_profile_constants['headset_client'] not in profile_connected
- and bt_profile_constants['headset_client'] in profiles_set):
+ while (time.time() < end_time and
+ not profile_connected.issuperset(profiles_set)):
+ if (bt_profile_constants['headset_client'] not in profile_connected and
+ bt_profile_constants['headset_client'] in profiles_set):
if is_hfp_client_device_connected(pri_ad, sec_addr):
profile_connected.add(bt_profile_constants['headset_client'])
- if (bt_profile_constants['a2dp'] not in profile_connected
- and bt_profile_constants['a2dp'] in profiles_set):
+ if (bt_profile_constants['a2dp'] not in profile_connected and
+ bt_profile_constants['a2dp'] in profiles_set):
if is_a2dp_src_device_connected(pri_ad, sec_addr):
profile_connected.add(bt_profile_constants['a2dp'])
- if (bt_profile_constants['a2dp_sink'] not in profile_connected
- and bt_profile_constants['a2dp_sink'] in profiles_set):
+ if (bt_profile_constants['a2dp_sink'] not in profile_connected and
+ bt_profile_constants['a2dp_sink'] in profiles_set):
if is_a2dp_snk_device_connected(pri_ad, sec_addr):
profile_connected.add(bt_profile_constants['a2dp_sink'])
- if (bt_profile_constants['map_mce'] not in profile_connected
- and bt_profile_constants['map_mce'] in profiles_set):
+ if (bt_profile_constants['map_mce'] not in profile_connected and
+ bt_profile_constants['map_mce'] in profiles_set):
if is_map_mce_device_connected(pri_ad, sec_addr):
profile_connected.add(bt_profile_constants['map_mce'])
- if (bt_profile_constants['map'] not in profile_connected
- and bt_profile_constants['map'] in profiles_set):
+ if (bt_profile_constants['map'] not in profile_connected and
+ bt_profile_constants['map'] in profiles_set):
if is_map_mse_device_connected(pri_ad, sec_addr):
profile_connected.add(bt_profile_constants['map'])
time.sleep(0.1)
@@ -600,8 +600,8 @@
def generate_id_by_size(size,
- chars=(string.ascii_lowercase +
- string.ascii_uppercase + string.digits)):
+ chars=(string.ascii_lowercase + string.ascii_uppercase +
+ string.digits)):
"""Generate random ascii characters of input size and input char types
Args:
@@ -710,7 +710,11 @@
return otp_dict
-def get_bt_metric(ad_list, duration=1, tag="bt_metric", processed=True):
+def get_bt_metric(ad_list,
+ duration=1,
+ bqr_tag='Monitoring , Handle:',
+ tag='',
+ log_path=False):
""" Function to get the bt metric from logcat.
Captures logcat for the specified duration and returns the bqr results.
@@ -719,21 +723,36 @@
Args:
ad_list: list of android_device objects
- duration: time duration (seconds) for which the logcat is parsed.
- tag: tag to be appended to the logcat dump.
- processed: flag to process bqr output.
+ duration: time duration (seconds) for which the logcat is parsed
+ bqr_tag: tag of bt metrics
+ tag: tag to be appended to the metrics raw data
+ log_path: path of metrics raw data
Returns:
- metrics_dict: dict of metrics for each android device.
+ process_data: dict of process raw data for each android devices
"""
- # Defining bqr quantitites and their regex to extract
+ # Defining bqr quantites and their regex to extract
regex_dict = {
- "vsp_txpl": "VSP_TxPL:\s(\S+)",
"pwlv": "PwLv:\s(\S+)",
- "rssi": "RSSI:\s[-](\d+)"
+ "rssi": "RSSI:\s[-](\d+)",
+ "rssi_c0": "RSSI_C0:\s[-](\d+)",
+ "rssi_c1": "RSSI_C1:\s[-](\d+)",
+ "txpw_c0": "\sTxPw_C0:\s(-?\d+)",
+ "txpw_c1": "\sTxPw_C1:\s(-?\d+)",
+ "bftx": "BFTx:\s(\w+)",
+ "divtx": "DivTx:\s(\w+)"
}
- metrics_dict = {"rssi": {}, "pwlv": {}, "vsp_txpl": {}}
+ metrics_dict = {
+ "rssi": {},
+ "pwlv": {},
+ "rssi_c0": {},
+ "rssi_c1": {},
+ "txpw_c0": {},
+ "txpw_c1": {},
+ "bftx": {},
+ "divtx": {}
+ }
# Converting a single android device object to list
if not isinstance(ad_list, list):
@@ -749,8 +768,7 @@
end_time = utils.get_current_epoch_time()
for ad in ad_list:
- bt_rssi_log = ad.cat_adb_log(tag, begin_time, end_time)
- bqr_tag = "Handle:"
+ bt_rssi_log = ad.cat_adb_log(tag + "_bt_metric", begin_time, end_time)
# Extracting supporting bqr quantities
for metric, regex in regex_dict.items():
@@ -762,33 +780,97 @@
m = re.findall(regex, line)[0].strip(",")
bqr_metric.append(m)
metrics_dict[metric][ad.serial] = bqr_metric
+ file_bt_log.close()
- # Formatting the raw data
- metrics_dict["rssi"][ad.serial] = [
- (-1) * int(x) for x in metrics_dict["rssi"][ad.serial]
- ]
- metrics_dict["pwlv"][ad.serial] = [
- int(x, 16) if '0x' in x else int(x, 10) for x in metrics_dict["pwlv"][ad.serial]
- ]
+ # Formatting and saving the raw data
+ metrics_to_be_formatted = [{
+ "name": "rssi",
+ "averagble": "y"
+ }, {
+ "name": "rssi_c0",
+ "averagble": "y"
+ }, {
+ "name": "rssi_c1",
+ "averagble": "y"
+ }, {
+ "name": "pwlv",
+ "averagble": "n"
+ }, {
+ "name": "txpw_c0",
+ "averagble": "n"
+ }, {
+ "name": "txpw_c1",
+ "averagble": "n"
+ }, {
+ "name": "bftx",
+ "averagble": "n"
+ }, {
+ "name": "divtx",
+ "averagble": "n"
+ }]
+ for metric in metrics_to_be_formatted:
+ if metric["averagble"] == "y":
+ metrics_dict[metric["name"]][ad.serial] = [
+ (-1) * int(x)
+ for x in metrics_dict[metric["name"]][ad.serial]
+ ]
+ else:
+ metrics_dict[metric["name"]][ad.serial] = [
+ int(x, 16) if '0x' in x else int(x, 10)
+ for x in metrics_dict[metric["name"]][ad.serial]
+ ]
+ # Saving metrics raw data for each attenuation
+ if log_path:
+ output_file_name = ad.serial + "_metrics_raw_data_" + tag + ".csv"
+ output_file = os.path.join(log_path, output_file_name)
+ os.makedirs(log_path, exist_ok=True)
+ df_save_metrics = {}
+ for item in metrics_dict.items():
+ df_save_metrics[item[0]] = next(iter(item[1].items()))[1]
+ MetricsDict_df = pd.DataFrame({key:pd.Series(value) for key, value in df_save_metrics.items()})
+ MetricsDict_df.to_csv(output_file)
+ # Defining the process_data_dict
+ process_data = {
+ "rssi": {},
+ "pwlv": {},
+ "rssi_c0": {},
+ "rssi_c1": {},
+ "txpw_c0": {},
+ "txpw_c1": {},
+ "bftx": {},
+ "divtx": {}
+ }
- # Processing formatted data if processing is required
- if processed:
- metrics_dict["rssi"][ad.serial] = [
- x for x in metrics_dict["rssi"][ad.serial] if x !=0 and x != -127
- ]
- # Computes the average RSSI
- metrics_dict["rssi"][ad.serial] = round(
- sum(metrics_dict["rssi"][ad.serial]) /
- len(metrics_dict["rssi"][ad.serial]), 2)
- # Returns last noted value for power level
- metrics_dict["pwlv"][ad.serial] = float(
- sum(metrics_dict["pwlv"][ad.serial]) /
- len(metrics_dict["pwlv"][ad.serial]))
+ # Computing and returning the raw data
+ for metric in metrics_to_be_formatted:
+ if metric["averagble"] == "y":
+ process_data[metric["name"]][ad.serial] = [
+ x for x in metrics_dict[metric["name"]][ad.serial]
+ if x != 0 and x != -127
+ ]
- return metrics_dict
+ try:
+ #DOING AVERAGE
+ process_data[metric["name"]][ad.serial] = round(
+ sum(metrics_dict[metric["name"]][ad.serial]) /
+ len(metrics_dict[metric["name"]][ad.serial]), 2)
+ except ZeroDivisionError:
+ #SETTING VALUE TO 'n/a'
+ process_data[metric["name"]][ad.serial] = "n/a"
+ else:
+ try:
+ #GETTING MOST_COMMON_VALUE
+ process_data[metric["name"]][ad.serial] = max(
+ metrics_dict[metric["name"]][ad.serial],
+ key=metrics_dict[metric["name"]][ad.serial].count)
+ except ValueError:
+ #SETTING VALUE TO 'n/a'
+ process_data[metric["name"]][ad.serial] = "n/a"
+
+ return process_data
-def get_bt_rssi(ad, duration=1, processed=True):
+def get_bt_rssi(ad, duration=1, processed=True, tag='', log_path=False):
"""Function to get average bt rssi from logcat.
This function returns the average RSSI for the given duration. RSSI values are
@@ -801,11 +883,7 @@
Returns:
avg_rssi: average RSSI on each android device for the given duration.
"""
- function_tag = "get_bt_rssi"
- bqr_results = get_bt_metric(ad,
- duration,
- tag=function_tag,
- processed=processed)
+ bqr_results = get_bt_metric(ad, duration, tag=tag, log_path=log_path)
return bqr_results["rssi"]
@@ -1201,8 +1279,7 @@
test_result = False
time.sleep(1)
if not test_result:
- client_ad.log.error(
- "Failed to establish a Bluetooth socket connection")
+ client_ad.log.error("Failed to establish a Bluetooth socket connection")
return False
return True
@@ -1253,9 +1330,8 @@
str(curr_attempts)))
return False
if not clear_bonded_devices(sec_ad):
- log.error(
- "Failed to clear bond for secondary device at attempt {}".
- format(str(curr_attempts)))
+ log.error("Failed to clear bond for secondary device at attempt {}".
+ format(str(curr_attempts)))
return False
# Wait 2 seconds after unbound
time.sleep(2)
@@ -1407,11 +1483,10 @@
droid, ed = android_device.droid, android_device.ed
if not droid.bluetoothA2dpSetCodecConfigPreference(
codec_types[codec_type], sample_rates[str(sample_rate)],
- bits_per_samples[str(bits_per_sample)],
- channel_modes[channel_mode], codec_specific_1):
- android_device.log.warning(
- "SL4A command returned False. Codec was not "
- "changed.")
+ bits_per_samples[str(bits_per_sample)], channel_modes[channel_mode],
+ codec_specific_1):
+ android_device.log.warning("SL4A command returned False. Codec was not "
+ "changed.")
else:
try:
ed.pop_event(bluetooth_a2dp_codec_config_changed,
@@ -1623,8 +1698,8 @@
out_name = ','.join((testname, device_model, serial))
snoop_path = os.path.join(ad.device_log_path, 'BluetoothSnoopLogs')
os.makedirs(snoop_path, exist_ok=True)
- cmd = ''.join(("adb -s ", serial, " pull ", btsnoop_log_path_on_device,
- " ", snoop_path + '/' + out_name, ".btsnoop_hci.log"))
+ cmd = ''.join(("adb -s ", serial, " pull ", btsnoop_log_path_on_device, " ",
+ snoop_path + '/' + out_name, ".btsnoop_hci.log"))
exe_cmd(cmd)
try:
cmd = ''.join(
@@ -1745,9 +1820,8 @@
timeout=bt_default_timeout)
sec_variant = sec_pairing_req["data"]["PairingVariant"]
sec_pin = sec_pairing_req["data"]["Pin"]
- sec_ad.log.info(
- "Secondary device received Pin: {}, Variant: {}".format(
- sec_pin, sec_variant))
+ sec_ad.log.info("Secondary device received Pin: {}, Variant: {}".format(
+ sec_pin, sec_variant))
except Empty as err:
log.error("Wait for pin error: {}".format(err))
log.error("Pairing request state, Primary: {}, Secondary: {}".format(
@@ -1813,6 +1887,7 @@
"""Media control using sl4a facade for general purpose.
"""
+
def __init__(self, android_device, music_file):
"""Initialize the media_control class.
diff --git a/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py b/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py
new file mode 100644
index 0000000..9fe9fa4
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/GnssBlankingBase.py
@@ -0,0 +1,505 @@
+#!/usr/bin/env python3
+#
+# 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 os
+from glob import glob
+from time import sleep
+from collections import namedtuple
+from numpy import arange
+from pandas import DataFrame
+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.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 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):
+ """
+ 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:
+ start: start value.
+ Type, int or float.
+ stop: stop value.
+ Type, int or float.
+ step: step value.
+ Type, int or float.
+ Returns:
+ range_ls: the list of data.
+ """
+ if step == 0:
+ ad.log.warn('Step is 0. Return empty list')
+ range_ls = []
+ else:
+ if start == stop:
+ range_ls = [stop]
+ else:
+ range_ls = list(arange(start, stop, step))
+ if len(range_ls) > 0:
+ if (step < 0 and range_ls[-1] > stop) or (step > 0 and
+ range_ls[-1] < stop):
+ range_ls.append(stop)
+ return range_ls
+
+
+def check_ttff_pe(ad, ttff_data, ttff_mode, pe_criteria):
+ """Verify all TTFF results from ttff_data.
+
+ Args:
+ ad: 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))
+
+ if len(ttff_data.keys()) == 0:
+ ad.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))
+ ret = False
+ else:
+ ad.log.info("All TTFF %s are within test criteria %f meters." %
+ (ttff_mode, pe_criteria))
+ ret = True
+ return ret
+
+
+class GnssBlankingBase(lttb.LabTtffTestBase):
+ """ LAB GNSS Cellular Coex Tx Power Sweep TTFF/FFPE Tests"""
+
+ def __init__(self, controllers):
+ """ Initializes class attributes. """
+ super().__init__(controllers)
+ self.eecoex_func = ''
+ self.start_pwr = 10
+ self.stop_pwr = 24
+ self.offset = 1
+ self.result_cell_pwr = 10
+ 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
+
+ def setup_class(self):
+ super().setup_class()
+ req_params = ['sa_sensitivity', 'gnss_pwr_lvl_offset']
+ 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)
+
+ def setup_test(self):
+ super().setup_test()
+ launch_eecoexer(self.dut)
+
+ # Set DUT temperature the limit to 60 degree
+ self.dut.adb.shell(
+ 'setprop persist.com.google.eecoexer.cellular.temperature_limit 60')
+
+ # Get current context full path to create the log folder.
+ cur_test_item_dir = get_current_context().get_full_output_path()
+ 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)
+
+ def teardown_test(self):
+ super().teardown_test()
+ # Set gnss_vendor_log_path based on GNSS solution vendor.
+ gnss_vendor_log_path = os.path.join(self.gnss_log_path,
+ 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 cellular Tx and close GPStool and EEcoexer APPs.
+ self.stop_cell_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):
+ """
+ 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)
+
+ def analysis_ttff_ffpe(self, ttff_data, json_tag=''):
+ """
+ Pull logs and parsing logs into json file.
+ Args:
+ ttff_data: ttff_data from test results.
+ Type, list.
+ json_tag: tag for parsed json file name.
+ Type, str.
+ """
+ # Create log directory.
+ gps_log_path = os.path.join(self.gnss_log_path,
+ 'Cell_Pwr_Sweep_Results')
+
+ # Pull logs of GTW GPStool.
+ 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)
+ 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))
+ try:
+ 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_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))))
+
+ 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 gnss_hot_start_ttff_ffpe_test(self,
+ iteration,
+ sweep_enable=False,
+ json_tag=''):
+ """
+ GNSS hot start ttff ffpe tset
+
+ Args:
+ iteration: hot start TTFF test iteration.
+ Type, int.
+ Default, 1.
+ sweep_enable: Indicator for the function to check if it is run by cell_power_sweep()
+ Type, bool.
+ Default, False.
+ json_tag: if the function is run by cell_power_sweep(), the function would use
+ this as a part of file name to save TTFF and FFPE results into json file.
+ Type, str.
+ Default, ''.
+ 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_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)
+
+ # Stop GTW GPSTool
+ self.dut.log.info("Stop GTW GPSTool")
+ start_gnss_by_gtw_gpstool(self.dut, state=False)
+
+ if sweep_enable:
+ self.analysis_ttff_ffpe(ttff_data, json_tag)
+
+ result_ttff = check_ttff_data(self.dut,
+ ttff_data,
+ ttff_mode=test_type_ttff.command,
+ criteria=test_type_ttff.criteria)
+ result_pe = check_ttff_pe(self.dut,
+ ttff_data,
+ ttff_mode=test_type_pe.command,
+ pe_criteria=test_type_pe.criteria)
+ if not result_ttff or not result_pe:
+ self.dut.log.warning('%s TTFF fails to reach '
+ 'designated criteria' % test_type_ttff.command)
+ self.dut.log.info("Stop GTW GPSTool")
+ return False
+
+ return True
+
+ def hot_start_gnss_power_sweep(self,
+ start_pwr,
+ stop_pwr,
+ offset,
+ wait,
+ iteration=1,
+ sweep_enable=False,
+ title=''):
+ """
+ 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.
+ wait: Wait time before the power sweep.
+ Type, int.
+ iteration: The iteration times of hot start test.
+ Type, int.
+ Default, 1.
+ sweep_enable: Indicator for power sweep.
+ It will be True only in GNSS sensitivity search case.
+ Type, bool.
+ Defaule, False.
+ title: the target log folder title for GNSS sensitivity search test items.
+ Type, str.
+ Default, ''.
+ """
+
+ # 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))
+
+ if sweep_enable:
+ self.start_gnss_and_wait(wait)
+ else:
+ self.dut.log.info('Wait %d seconds to start TTFF HS' % wait)
+ sleep(wait)
+
+ # 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 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
+
+ def gnss_init_power_setting(self, first_wait=180):
+ """
+ GNSS initial power level setting.
+ Args:
+ first_wait: wait time after the cold start.
+ Type, int.
+ Default, 180.
+ Returns:
+ True if the process is done successully and hot start results pass criteria.
+ Raise:
+ TestFailure: fail TTFF test criteria.
+ """
+
+ # Start and set GNSS simulator
+ self.start_and_set_gnss_simulator_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)
+
+ 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)
+
+ def cell_power_sweep(self):
+ """
+ Linear search cellular power level. Doing GNSS hot start with cellular coexistence
+ and checking if hot start can pass hot start criteria or not.
+
+ Returns: final power level of cellular power
+ """
+ # Get parameters from user params.
+ ttft_iteration = self.user_params.get('ttff_iteration', 25)
+ wait_before_test = self.user_params.get('wait_before_test', 60)
+ wait_between_pwr = self.user_params.get('wait_between_pwr', 60)
+ power_th = self.start_pwr
+
+ # Generate the power sweep list.
+ 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')
+
+ # Pull all exist GPStool logs into GNSS_init folder
+ get_gpstool_logs(self.dut, gnss_init_log_dir, False)
+
+ 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)))
+
+ # Enable GNSS to receive satellites' signals for "wait_between_pwr" seconds.
+ # Wait more time before 1st power level
+ if i == 0:
+ wait = wait_before_test
+ else:
+ wait = wait_between_pwr
+ self.start_gnss_and_wait(wait)
+
+ # Set cellular Tx power level.
+ eecoex_cmd = self.eecoex_func.format(str(pwr_lvl))
+ eecoex_cmd_file_str = eecoex_cmd.replace(',', '_')
+ excute_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,
+ eecoex_cmd_file_str):
+ if i + 1 == len(power_search_ls):
+ power_th = pwr_lvl
+ else:
+ if i == 0:
+ power_th = self.start_pwr
+ else:
+ power_th = power_search_ls[i - 1]
+
+ # Stop cellular Tx after a test cycle.
+ self.stop_cell_tx()
+
+ else:
+ # Run the stand alone test item.
+ self.start_gnss_and_wait(wait_between_pwr)
+
+ eecoex_cmd_file_str = 'no_cellular_coex'
+ 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)))
+
+ 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
new file mode 100644
index 0000000..6a6bd5d
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/LabTtffTestBase.py
@@ -0,0 +1,349 @@
+#!/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
+import time
+import glob
+import errno
+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 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
+
+
+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'
+ CUSTOM_FILES_KEY = 'custom_files'
+ CSTTFF_CRITERIA = 'cs_criteria'
+ HSTTFF_CRITERIA = 'hs_criteria'
+ WSTTFF_CRITERIA = 'ws_criteria'
+ CSTTFF_PECRITERIA = 'cs_ttff_pecriteria'
+ HSTTFF_PECRITERIA = 'hs_ttff_pecriteria'
+ WSTTFF_PECRITERIA = 'ws_ttff_pecriteria'
+ TTFF_ITERATION = 'ttff_iteration'
+ SIMULATOR_LOCATION = 'simulator_location'
+ DIAG_OPTION = 'diag_option'
+
+ 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'
+
+ 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
+ ]
+
+ self.unpack_userparams(req_param_names=req_params)
+ 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, [])
+
+ # 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]
+ if gnss_simulator_key == 'gss7000':
+ gnss_simulator_port_ctrl = self.user_params[
+ self.GNSS_SIMULATOR_PORT_CTRL_KEY]
+ 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
+
+ def setup_test(self):
+
+ self.clear_gps_log()
+ 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.dut_rockbottom()
+ else:
+ self.log.info('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)
+
+ # 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)
+ self.dut.adb.shell(copy_cmd)
+ gutils.delete_bcm_nvmem_sto_file(self.dut)
+ gutils.bcm_gps_ignore_rom_alm(self.dut)
+ # Reboot DUT to apply the setting
+ gutils.reboot(self.dut)
+ self.gnss_simulator.connect()
+
+ def dut_rockbottom(self):
+ """
+ Set the dut to rockbottom state
+
+ """
+ # 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)
+ os.chmod(self.rockbottom_script, 0o777)
+ os.system('{} {}'.format(self.rockbottom_script, self.dut.serial))
+ # Make sure the DUT is in root mode after coming back
+ self.dut.root_adb()
+ # Restart SL4A
+ self.dut.start_services()
+
+ def teardown_test(self):
+ """Teardown settings for the test class"""
+ super().teardown_test()
+ # 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)
+ self.dut.adb.shell(rm_cmd)
+ self.dut.adb.shell(restore_cmd)
+
+ def teardown_class(self):
+ """ Executed after completing all selected test cases."""
+ self.clear_gps_log()
+ if self.gnss_simulator:
+ self.gnss_simulator.stop_scenario()
+ self.gnss_simulator.close()
+
+ def start_and_set_gnss_simulator_power(self):
+ """
+ Start GNSS simulator secnario and set power level.
+
+ """
+
+ self.gnss_simulator.start_scenario(self.gnss_simulator_scenario)
+ time.sleep(25)
+ self.gnss_simulator.set_power(self.gnss_simulator_power_level)
+
+ def get_and_verify_ttff(self, mode):
+ """Retrieve ttff with designate mode.
+
+ Args:
+ mode: A string for identify gnss test mode.
+ """
+ if mode not in self.test_types:
+ raise signals.TestError('Unrecognized mode %s' % 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()
+ gutils.start_ttff_by_gtw_gpstool(self.dut,
+ ttff_mode=mode,
+ iteration=self.ttff_iteration,
+ raninterval=True,
+ hot_warm_sleep=wait_time)
+ # 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)
+
+ # Create folder for GTW GPStool's log
+ 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()))
+
+ 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]))
+
+ ttff_dict = {}
+ for i in ttff_data:
+ d = ttff_data[i]._asdict()
+ ttff_dict[i] = dict(d)
+
+ 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')
+ 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)
+ return ttff_data
+
+ def verify_pe(self, mode):
+ """
+ Verify ttff Position Error with designate mode.
+
+ Args:
+ mode: A string for identify gnss test mode.
+ """
+
+ ffpe_type = namedtuple('Type', ['command', 'pecriteria'])
+ ffpe_types = {
+ 'cs': ffpe_type('Cold Start', self.cs_ttff_pecriteria),
+ 'ws': ffpe_type('Warm Start', self.ws_ttff_pecriteria),
+ 'hs': ffpe_type('Hot Start', self.hs_ttff_pecriteria)
+ }
+
+ if mode not in ffpe_types:
+ raise signals.TestError('Unrecognized mode %s' % mode)
+ test_type = ffpe_types.get(mode)
+
+ ttff_data = self.get_and_verify_ttff(mode)
+ result = gutils.check_ttff_pe(self.dut,
+ ttff_data,
+ 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)
+ return ttff_data
+
+ def clear_gps_log(self):
+ """
+ Delete the existing GPS GTW Log from DUT.
+
+ """
+ self.dut.adb.shell("rm -rf {}".format(DEVICE_GPSLOG_FOLDER))
+
+ def gnss_ttff_ffpe(self, mode, sub_context_path=''):
+ """
+ Base ttff and ffpe function
+ Args:
+ mode: Set the TTFF mode for testing. Definitions are as below.
+ cs(cold start), ws(warm start), hs(hot start)
+ sub_context_path: Set specifc log pathfor ttff_ffpe
+ """
+ # Create log file path
+ 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))
+
+ # Start and set GNSS simulator
+ self.start_and_set_gnss_simulator_power()
+
+ # 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)
+
+ # Start verifying TTFF and FFPE
+ self.verify_pe(mode)
+
+ # Set gnss_vendor_log_path based on GNSS solution vendor
+ gnss_vendor_log_path = os.path.join(self.gnss_log_path,
+ 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":
+ 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)
diff --git a/acts_tests/acts_contrib/test_utils/gnss/dut_log_test_utils.py b/acts_tests/acts_contrib/test_utils/gnss/dut_log_test_utils.py
index a685b65..cba71f1 100644
--- a/acts_tests/acts_contrib/test_utils/gnss/dut_log_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/gnss/dut_log_test_utils.py
@@ -18,12 +18,14 @@
import time
import errno
+
DEVICE_CFG_FOLDER = "/data/vendor/radio/diag_logs/cfg/"
DEVICE_DIAGMDLOG_FOLDER = "/data/vendor/radio/diag_logs/logs/"
MDLOG_SETTLING_TIME = 2
MDLOG_PROCESS_KILL_TIME = 3
NOHUP_CMD = "nohup diag_mdlog -f {} -o {} -s 100 -c &> /dev/null &"
DEVICE_GPSLOG_FOLDER = '/sdcard/Android/data/com.android.gpstool/files/'
+DEVICE_PIXEL_LOGGER_FOLDER = '/sdcard/Android/data/com.android.pixellogger/files/logs/gps/'
def find_device_qxdm_log_mask(ad, maskfile):
@@ -169,9 +171,30 @@
"""
gps_log_path = os.path.join(local_logpath, 'GPSLogs')
+ os.makedirs(gps_log_path, exist_ok=True)
ad.adb.pull("{} {}".format(DEVICE_GPSLOG_FOLDER, gps_log_path))
ad.log.debug("gpstool logs are pulled from device")
if not keep_logs:
- ad.adb.shell("rm -rf " + DEVICE_GPSLOG_FOLDER + "*.*")
- ad.log.debug("gpstool logs are deleted from device")
\ No newline at end of file
+ gpstool_log_path = os.path.join(DEVICE_GPSLOG_FOLDER, "*")
+ ad.adb.shell("rm -rf " + gpstool_log_path)
+ ad.log.debug("gpstool logs are deleted from device")
+
+def get_pixellogger_bcm_log(ad, local_logpath, keep_logs=True):
+ """
+
+ Pulls BCM Logs from android device
+
+ Args:
+ ad: the target android device, AndroidDevice object
+ local_logpath: Local file path to pull the gpstool logs
+ keep_logs: False, delete log files from the gpstool log path
+ """
+
+ ad.adb.pull("{} {}".format(DEVICE_PIXEL_LOGGER_FOLDER, local_logpath))
+ ad.log.debug("pixellogger logs are pulled from device")
+
+ if not keep_logs:
+ bcm_log_path = os.path.join(DEVICE_PIXEL_LOGGER_FOLDER, "*")
+ ad.adb.shell("rm -rf " + bcm_log_path)
+ ad.log.debug("pixellogger logs are deleted from device")
\ No newline at end of file
diff --git a/acts_tests/acts_contrib/test_utils/gnss/gnss_defines.py b/acts_tests/acts_contrib/test_utils/gnss/gnss_defines.py
new file mode 100644
index 0000000..24eef0f
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/gnss/gnss_defines.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+#
+# 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.
+
+DEVICE_GPSLOG_FOLDER = '/sdcard/Android/data/com.android.gpstool/files/'
+GPS_PKG_NAME = 'com.android.gpstool'
+BCM_GPS_XML_PATH = '/vendor/etc/gnss/gps.xml'
+BCM_NVME_STO_PATH = '/data/vendor/gps/gldata.sto'
\ No newline at end of file
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 7b5c841..5efa817 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
@@ -22,7 +22,10 @@
import fnmatch
import posixpath
import tempfile
+import zipfile
from collections import namedtuple
+from datetime import datetime
+from xml.etree import ElementTree
from acts import utils
from acts import asserts
@@ -39,6 +42,8 @@
from acts_contrib.test_utils.instrumentation.device.command.instrumentation_command_builder import InstrumentationTestCommandBuilder
from acts.utils import get_current_epoch_time
from acts.utils import epoch_to_human_time
+from acts_contrib.test_utils.gnss.gnss_defines import BCM_GPS_XML_PATH
+from acts_contrib.test_utils.gnss.gnss_defines import BCM_NVME_STO_PATH
WifiEnums = wutils.WifiEnums
PULL_TIMEOUT = 300
@@ -47,7 +52,7 @@
QXDM_MASKS = ["GPS.cfg", "GPS-general.cfg", "default.cfg"]
TTFF_REPORT = namedtuple(
"TTFF_REPORT", "utc_time ttff_loop ttff_sec ttff_pe ttff_ant_cn "
- "ttff_base_cn")
+ "ttff_base_cn ttff_haccu")
TRACK_REPORT = namedtuple(
"TRACK_REPORT", "l5flag pe ant_top4cn ant_cn base_top4cn base_cn")
LOCAL_PROP_FILE_CONTENTS = """\
@@ -89,6 +94,11 @@
NORMAL_PSDS_SERVER="http://"
REALTIME_PSDS_SERVER="http://"
"""
+DISABLE_LTO_FILE_CONTENTS_R = """\
+XTRA_SERVER_1="http://"
+XTRA_SERVER_2="http://"
+XTRA_SERVER_3="http://"
+"""
class GnssTestUtilsError(Exception):
@@ -121,7 +131,7 @@
ad.log.info("Reboot device to make changes take effect.")
ad.reboot()
ad.unlock_screen(password=None)
- if not int(ad.adb.shell("settings get global mobile_data")) == 1:
+ if not is_mobile_data_on(ad):
set_mobile_data(ad, True)
utils.sync_device_time(ad)
@@ -185,7 +195,7 @@
"--es package com.google.android.location --es user \* "
"--esa flags %s --esa values %s --esa types %s "
"com.google.android.gms" % (flag, value, type))
- ad.adb.shell(cmd)
+ ad.adb.shell(cmd, ignore_status=True)
ad.adb.shell("am force-stop com.google.android.gms")
ad.adb.shell("am broadcast -a com.google.android.gms.INITIALIZE")
@@ -211,7 +221,9 @@
remount_device(ad)
ad.log.info("Enable SUPL mode.")
ad.adb.shell("echo -e '\nSUPL_MODE=1' >> /etc/gps_debug.conf")
- if not check_chipset_vendor_by_qualcomm(ad):
+ 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)
@@ -226,7 +238,9 @@
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):
+ 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)
@@ -239,7 +253,9 @@
ad: An AndroidDevice object.
"""
ad.root_adb()
- if check_chipset_vendor_by_qualcomm(ad):
+ 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)
else:
@@ -268,10 +284,14 @@
"""
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)
- ad.adb.shell("settings put system screen_off_timeout 1800000")
+ 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)
ad.log.info("Setting Bluetooth state to False")
ad.droid.bluetoothToggleState(False)
@@ -280,6 +300,61 @@
disable_private_dns_mode(ad)
reboot(ad)
init_gtw_gpstool(ad)
+ if not is_mobile_data_on(ad):
+ set_mobile_data(ad, True)
+
+
+def prepare_gps_overlay(ad):
+ """Set pixellogger gps log mask to
+ resolve gps logs unreplayable from brcm vendor
+ """
+ if not check_chipset_vendor_by_qualcomm(ad):
+ overlay_file = "/data/vendor/gps/overlay/gps_overlay.xml"
+ xml_file = generate_gps_overlay_xml(ad)
+ try:
+ ad.log.info("Push gps_overlay to device")
+ ad.adb.push(xml_file, overlay_file)
+ ad.adb.shell(f"chmod 777 {overlay_file}")
+ finally:
+ xml_folder = os.path.abspath(os.path.join(xml_file, os.pardir))
+ shutil.rmtree(xml_folder)
+
+
+def generate_gps_overlay_xml(ad):
+ """For r11 devices, the overlay setting is 'Replayable default'
+ For other brcm devices, the setting is 'Replayable debug'
+
+ Returns:
+ path to the xml file
+ """
+ root_attrib = {
+ "xmlns": "http://www.glpals.com/",
+ "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+ "xsi:schemaLocation": "http://www.glpals.com/ glconfig.xsd",
+ }
+ sub_attrib = {"EnableOnChipStopNotification": "true"}
+ if not is_device_wearable(ad):
+ sub_attrib["LogPriMask"] = "LOG_DEBUG"
+ sub_attrib["LogFacMask"] = "LOG_GLLIO | LOG_GLLAPI | LOG_NMEA | LOG_RAWDATA"
+ sub_attrib["OnChipLogPriMask"] = "LOG_DEBUG"
+ sub_attrib["OnChipLogFacMask"] = "LOG_GLLIO | LOG_GLLAPI | LOG_NMEA | LOG_RAWDATA"
+
+ temp_path = tempfile.mkdtemp()
+ xml_file = os.path.join(temp_path, "gps_overlay.xml")
+
+ root = ElementTree.Element('glgps')
+ for key, value in root_attrib.items():
+ root.attrib[key] = value
+
+ ad.log.debug("Sub attrib is %s", sub_attrib)
+
+ sub = ElementTree.SubElement(root, 'gll')
+ for key, value in sub_attrib.items():
+ sub.attrib[key] = value
+
+ xml = ElementTree.ElementTree(root)
+ xml.write(xml_file, xml_declaration=True, encoding="utf-8", method="xml")
+ return xml_file
def connect_to_wifi_network(ad, network):
@@ -324,6 +399,7 @@
"""
remount_device(ad)
utils.set_location_service(ad, True)
+ ad.adb.shell("cmd location set-location-enabled true")
location_mode = int(ad.adb.shell("settings get secure location_mode"))
ad.log.info("Current Location Mode >> %d" % location_mode)
if location_mode != 3:
@@ -356,7 +432,7 @@
reboot(ad)
-def get_gnss_qxdm_log(ad, qdb_path):
+def get_gnss_qxdm_log(ad, qdb_path=None):
"""Get /storage/emulated/0/Android/data/com.android.gpstool/files and
/data/vendor/radio/diag_logs/logs for test item.
@@ -370,16 +446,17 @@
gnss_log_path = posixpath.join(log_path, gnss_log_name)
os.makedirs(gnss_log_path, exist_ok=True)
ad.log.info("Pull GnssStatus Log to %s" % gnss_log_path)
- ad.adb.pull("%s %s" % (GNSSSTATUS_LOG_PATH+".", gnss_log_path),
+ ad.adb.pull("%s %s" % (GNSSSTATUS_LOG_PATH + ".", gnss_log_path),
timeout=PULL_TIMEOUT, ignore_status=True)
shutil.make_archive(gnss_log_path, "zip", gnss_log_path)
- shutil.rmtree(gnss_log_path)
+ shutil.rmtree(gnss_log_path, ignore_errors=True)
if check_chipset_vendor_by_qualcomm(ad):
output_path = (
- "/sdcard/Android/data/com.android.pixellogger/files/logs/diag_logs")
+ "/sdcard/Android/data/com.android.pixellogger/files/logs/"
+ "diag_logs/.")
else:
output_path = (
- "/sdcard/Android/data/com.android.pixellogger/files/logs/gps/")
+ "/sdcard/Android/data/com.android.pixellogger/files/logs/gps/.")
qxdm_log_name = "PixelLogger_%s_%s" % (ad.model, ad.serial)
qxdm_log_path = posixpath.join(log_path, qxdm_log_name)
os.makedirs(qxdm_log_path, exist_ok=True)
@@ -395,7 +472,7 @@
continue
break
shutil.make_archive(qxdm_log_path, "zip", qxdm_log_path)
- shutil.rmtree(qxdm_log_path)
+ shutil.rmtree(qxdm_log_path, ignore_errors=True)
def set_mobile_data(ad, state):
@@ -407,19 +484,27 @@
"""
ad.root_adb()
if state:
- ad.log.info("Enable mobile data.")
- ad.adb.shell("svc data enable")
+ if is_device_wearable(ad):
+ ad.log.info("Enable wearable mobile data.")
+ ad.adb.shell("settings put global cell_on 1")
+ else:
+ ad.log.info("Enable mobile data via RPC call.")
+ ad.droid.telephonyToggleDataConnection(True)
else:
- ad.log.info("Disable mobile data.")
- ad.adb.shell("svc data disable")
+ if is_device_wearable(ad):
+ ad.log.info("Disable wearable mobile data.")
+ ad.adb.shell("settings put global cell_on 0")
+ else:
+ ad.log.info("Disable mobile data via RPC call.")
+ ad.droid.telephonyToggleDataConnection(False)
time.sleep(5)
- out = int(ad.adb.shell("settings get global mobile_data"))
- if state and out == 1:
- ad.log.info("Mobile data is enabled and set to %d" % out)
- elif not state and out == 0:
- ad.log.info("Mobile data is disabled and set to %d" % out)
+ ret_val = is_mobile_data_on(ad)
+ if state and ret_val:
+ ad.log.info("Mobile data is enabled and set to %s" % ret_val)
+ elif not state and not ret_val:
+ ad.log.info("Mobile data is disabled and set to %s" % ret_val)
else:
- ad.log.error("Mobile data is at unknown state and set to %d" % out)
+ ad.log.error("Mobile data is at unknown state and set to %s" % ret_val)
def gnss_trigger_modem_ssr_by_adb(ad, dwelltime=60):
@@ -504,6 +589,11 @@
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)
@@ -525,11 +615,10 @@
Returns:
The temp path of pulled apk.
"""
- apk_path = None
out = ad.adb.shell("pm path %s" % package_name)
result = re.search(r"package:(.*)", out)
if not result:
- tutils.abort_all_tests(ad.log, "Couldn't find apk of %s" % package_name)
+ raise signals.TestError("Couldn't find apk of %s" % package_name)
else:
apk_source = result.group(1)
ad.log.info("Get apk of %s from %s" % (package_name, apk_source))
@@ -593,9 +682,10 @@
remount_device(ad)
gpstool_path = pull_package_apk(ad, "com.android.gpstool")
reinstall_package_apk(ad, "com.android.gpstool", gpstool_path)
+ shutil.rmtree(gpstool_path, ignore_errors=True)
-def fastboot_factory_reset(ad):
+def fastboot_factory_reset(ad, state=True):
"""Factory reset the device in fastboot mode.
Pull sl4a apk from device. Terminate all sl4a sessions,
Reboot the device to bootloader,
@@ -605,23 +695,24 @@
Args:
ad: An AndroidDevice object.
+ State: True for exit_setup_wizard, False for not exit_setup_wizard.
Returns:
True if factory reset process complete.
"""
status = True
- skip_setup_wizard = True
+ mds_path = ""
+ gnss_cfg_file = ""
gnss_cfg_path = "/vendor/etc/mdlog"
default_gnss_cfg = "/vendor/etc/mdlog/DEFAULT+SECURITY+FULLDPL+GPS.cfg"
sl4a_path = pull_package_apk(ad, SL4A_APK_NAME)
gpstool_path = pull_package_apk(ad, "com.android.gpstool")
- mds_path = pull_package_apk(ad, "com.google.mdstest")
if check_chipset_vendor_by_qualcomm(ad):
+ mds_path = pull_package_apk(ad, "com.google.mdstest")
gnss_cfg_file = pull_gnss_cfg_file(ad, default_gnss_cfg)
stop_pixel_logger(ad)
ad.stop_services()
- attempts = 3
- for i in range(1, attempts + 1):
+ for i in range(1, 4):
try:
if ad.serial in list_adb_devices():
ad.log.info("Reboot to bootloader")
@@ -639,10 +730,13 @@
break
if ad.is_sl4a_installed():
break
+ if is_device_wearable(ad):
+ ad.log.info("Wait 5 mins for wearable projects system busy time.")
+ time.sleep(300)
reinstall_package_apk(ad, SL4A_APK_NAME, sl4a_path)
reinstall_package_apk(ad, "com.android.gpstool", gpstool_path)
- reinstall_package_apk(ad, "com.google.mdstest", mds_path)
if check_chipset_vendor_by_qualcomm(ad):
+ reinstall_package_apk(ad, "com.google.mdstest", mds_path)
ad.push_system_file(gnss_cfg_file, gnss_cfg_path)
time.sleep(10)
break
@@ -655,11 +749,13 @@
ad.start_adb_logcat()
except Exception as e:
ad.log.error(e)
- if skip_setup_wizard:
+ if state:
ad.exit_setup_wizard()
if ad.skip_sl4a:
return status
tutils.bring_up_sl4a(ad)
+ for path in [sl4a_path, gpstool_path, mds_path, gnss_cfg_file]:
+ shutil.rmtree(path, ignore_errors=True)
return status
@@ -762,7 +858,15 @@
raise signals.TestFailure("Fail to get %s location fixed within %d "
"attempts." % (type.upper(), retries))
-def start_ttff_by_gtw_gpstool(ad, ttff_mode, iteration, aid_data=False):
+
+def start_ttff_by_gtw_gpstool(ad,
+ ttff_mode,
+ iteration,
+ aid_data=False,
+ raninterval=False,
+ mininterval=10,
+ maxinterval=40,
+ hot_warm_sleep=300):
"""Identify which TTFF mode for different test items.
Args:
@@ -770,17 +874,28 @@
ttff_mode: TTFF Test mode for current test item.
iteration: Iteration of TTFF cycles.
aid_data: Boolean for identify aid_data existed or not
+ raninterval: Boolean for identify random interval of TTFF in enable or not.
+ 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.
"""
begin_time = get_current_epoch_time()
if (ttff_mode == "hs" or ttff_mode == "ws") and not aid_data:
- ad.log.info("Wait 5 minutes to start TTFF %s..." % ttff_mode.upper())
- time.sleep(300)
+ ad.log.info("Wait {} seconds to start TTFF {}...".format(
+ hot_warm_sleep, ttff_mode.upper()))
+ time.sleep(hot_warm_sleep)
if ttff_mode == "cs":
ad.log.info("Start TTFF Cold Start...")
time.sleep(3)
+ elif ttff_mode == "csa":
+ 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 %s --es cycle %d" % (ttff_mode, iteration))
+ "--es ttff {} --es cycle {} --ez raninterval {} "
+ "--ei mininterval {} --ei maxinterval {}".format(
+ ttff_mode, iteration, raninterval, mininterval,
+ maxinterval))
time.sleep(1)
if ad.search_logcat("act=com.android.gpstool.start_test_action",
begin_time):
@@ -806,30 +921,13 @@
meas_flag: True to enable GnssMeasurement. False is not to. Default
set to False.
"""
- gnss_crash_list = [".*Fatal signal.*gnss",
- ".*Fatal signal.*xtra",
- ".*F DEBUG.*gnss"]
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(),
testtime))
begin_time = get_current_epoch_time()
while get_current_epoch_time() - begin_time < testtime * 60 * 1000:
- 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)
- if gnss_crash_result:
- start_gnss_by_gtw_gpstool(ad, state=False, type=type)
- raise signals.TestFailure(
- "Test failed due to GNSS HAL crashed. \n%s" %
- gnss_crash_result)
- gpstool_crash_result = ad.search_logcat("Force finishing activity "
- "com.android.gpstool/.GPSTool",
- begin_time)
- if gpstool_crash_result:
- raise signals.TestError("GPSTool crashed. Abort test.")
+ 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)
@@ -967,6 +1065,8 @@
loc_time = int(
gnss_location_log[10].split("=")[-1].strip(","))
utc_time = epoch_to_human_time(loc_time)
+ ttff_haccu = float(
+ gnss_location_log[11].split("=")[-1].strip(","))
elif type == "flp":
flp_results = ad.search_logcat("GPSService: FLP Location",
begin_time)
@@ -976,12 +1076,14 @@
"log_message"].split()
ttff_lat = float(flp_location_log[8].split(",")[0])
ttff_lon = float(flp_location_log[8].split(",")[1])
+ ttff_haccu = float(flp_location_log[9].split("=")[1])
utc_time = epoch_to_human_time(get_current_epoch_time())
else:
ttff_ant_cn = float(ttff_log[19].strip("]"))
ttff_base_cn = float(ttff_log[26].strip("]"))
ttff_lat = 0
ttff_lon = 0
+ ttff_haccu = 0
utc_time = epoch_to_human_time(get_current_epoch_time())
ad.log.debug("TTFF Loop %d - (Lat, Lon) = (%s, %s)" % (ttff_loop,
ttff_lat,
@@ -993,16 +1095,19 @@
ttff_sec=ttff_sec,
ttff_pe=ttff_pe,
ttff_ant_cn=ttff_ant_cn,
- ttff_base_cn=ttff_base_cn)
+ ttff_base_cn=ttff_base_cn,
+ ttff_haccu=ttff_haccu)
ad.log.info("UTC Time = %s, Loop %d = %.1f seconds, "
"Position Error = %.1f meters, "
"Antenna Average Signal = %.1f dbHz, "
- "Baseband Average Signal = %.1f dbHz" % (utc_time,
+ "Baseband Average Signal = %.1f dbHz, "
+ "Horizontal Accuracy = %.1f meters" % (utc_time,
ttff_loop,
ttff_sec,
ttff_pe,
ttff_ant_cn,
- ttff_base_cn))
+ ttff_base_cn,
+ ttff_haccu))
stop_gps_results = ad.search_logcat("stop gps test", begin_time)
if stop_gps_results:
ad.send_keycode("HOME")
@@ -1067,6 +1172,8 @@
ttff_data.keys()]
base_cn_list = [float(ttff_data[key].ttff_base_cn) for key in
ttff_data.keys()]
+ haccu_list = [float(ttff_data[key].ttff_haccu) for key in
+ ttff_data.keys()]
timeoutcount = sec_list.count(0.0)
if len(sec_list) == timeoutcount:
avgttff = 9527
@@ -1080,6 +1187,7 @@
maxdis = max(pe_list)
ant_avgcn = sum(ant_cn_list)/len(ant_cn_list)
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+"MaxTime %.1f" % maxttff)
ad.log.info(prop_basename+"TimeoutCount %d" % timeoutcount)
@@ -1087,6 +1195,7 @@
ad.log.info(prop_basename+"MaxDis %.1f" % maxdis)
ad.log.info(prop_basename+"Ant_AvgSignal %.1f" % ant_avgcn)
ad.log.info(prop_basename+"Base_AvgSignal %.1f" % base_avgcn)
+ ad.log.info(prop_basename+"Avg_Horizontal_Accuracy %.1f" % avg_haccu)
def calculate_position_error(latitude, longitude, true_position):
@@ -1119,12 +1228,16 @@
"""
ad.log.info("Launch Google Map.")
try:
- ad.adb.shell("am start -S -n com.google.android.apps.maps/"
- "com.google.android.maps.MapsActivity")
+ if is_device_wearable(ad):
+ cmd = ("am start -S -n com.google.android.apps.maps/"
+ "com.google.android.apps.gmmwearable.MainActivity")
+ else:
+ cmd = ("am start -S -n com.google.android.apps.maps/"
+ "com.google.android.maps.MapsActivity")
+ ad.adb.shell(cmd)
ad.send_keycode("BACK")
ad.force_stop_apk("com.google.android.apps.maps")
- ad.adb.shell("am start -S -n com.google.android.apps.maps/"
- "com.google.android.maps.MapsActivity")
+ ad.adb.shell(cmd)
except Exception as e:
ad.log.error(e)
raise signals.TestError("Failed to launch google map.")
@@ -1159,7 +1272,7 @@
ad.log.info("Try to get location report from GnssLocationProvider API "
"- attempt %d" % (i+1))
while get_current_epoch_time() - begin_time <= 30000:
- logcat_results = ad.search_logcat("REPORT_LOCATION", begin_time)
+ logcat_results = ad.search_logcat("reportLocation", begin_time)
if logcat_results:
ad.log.info("%s" % logcat_results[-1]["log_message"])
ad.log.info("GnssLocationProvider reports location "
@@ -1170,6 +1283,7 @@
ad.log.error("GnssLocationProvider is unable to report location.")
return False
+
def check_network_location(ad, retries, location_type, criteria=30):
"""Verify if NLP reports location after requesting via GPSTool.
@@ -1297,20 +1411,35 @@
ad: An AndroidDevice object.
extra_msg: Extra message before or after the change.
"""
+ mpss_version = ""
+ brcm_gps_version = ""
+ brcm_sensorhub_version = ""
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]
- mpss_version = ad.adb.shell("cat /sys/devices/soc0/images | grep MPSS "
- "| cut -d ':' -f 3")
+ if check_chipset_vendor_by_qualcomm(ad):
+ mpss_version = ad.adb.shell(
+ "cat /sys/devices/soc0/images | grep MPSS | cut -d ':' -f 3")
+ else:
+ brcm_gps_version = ad.adb.shell("cat /data/vendor/gps/chip.info")
+ sensorhub_version = ad.adb.shell(
+ "cat /vendor/firmware/SensorHub.patch | grep ChangeList")
+ brcm_sensorhub_version = re.compile(
+ r'<ChangeList=(\w+)>').search(sensorhub_version).group(1)
if not extra_msg:
ad.log.info("TestResult Build_Version %s" % build_version)
ad.log.info("TestResult Baseband_Version %s" % baseband_version)
ad.log.info(
"TestResult GMS_Version %s" % gms_version.replace(" ", ""))
- ad.log.info("TestResult MPSS_Version %s" % mpss_version)
+ if check_chipset_vendor_by_qualcomm(ad):
+ ad.log.info("TestResult MPSS_Version %s" % mpss_version)
+ else:
+ ad.log.info("TestResult GPS_Version %s" % brcm_gps_version)
+ ad.log.info(
+ "TestResult SensorHub_Version %s" % brcm_sensorhub_version)
else:
ad.log.info(
"%s, Baseband_Version = %s" % (extra_msg, baseband_version))
@@ -1332,7 +1461,14 @@
ad.adb.shell("am start -S -n com.android.gpstool/.GPSTool "
"--es mode toggle --es cycle %d" % iteration)
time.sleep(1)
- if ad.search_logcat("cmp=com.android.gpstool/.ToggleGPS",
+ if is_device_wearable(ad):
+ # Wait 20 seconds for Wearable low performance time.
+ time.sleep(20)
+ if ad.search_logcat("ToggleGPS onResume",
+ begin_time):
+ ad.log.info("Send ToggleGPS start_test_action successfully.")
+ break
+ elif ad.search_logcat("cmp=com.android.gpstool/.ToggleGPS",
begin_time):
ad.log.info("Send ToggleGPS start_test_action successfully.")
break
@@ -1341,7 +1477,11 @@
raise signals.TestError("Fail to send ToggleGPS "
"start_test_action within 3 attempts.")
time.sleep(2)
- test_start = ad.search_logcat("GPSTool_ToggleGPS: startService",
+ if is_device_wearable(ad):
+ test_start = ad.search_logcat("GPSService: create toggle GPS log",
+ begin_time)
+ else:
+ test_start = ad.search_logcat("GPSTool_ToggleGPS: startService",
begin_time)
if test_start:
ad.log.info(test_start[-1]["log_message"].split(":")[-1].strip())
@@ -1486,10 +1626,10 @@
pe_criteria: Criteria for current test item.
"""
- 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))
+ 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))
if len(ttff_data.keys()) == 0:
ad.log.error("GTW_GPSTool didn't process TTFF properly.")
@@ -1497,11 +1637,13 @@
elif 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))
+ ad.log.error("One or more TTFF %s are over test criteria %f meters"
+ % (ttff_mode, pe_criteria))
raise signals.TestFailure("GTW_GPSTool didn't process TTFF properly.")
- ad.log.info("All TTFF %s are within test criteria %f meters.",
- (ttff_mode, pe_criteria))
+ else:
+ ad.log.info("All TTFF %s are within test criteria %f meters." % (
+ ttff_mode, pe_criteria))
+ return True
def check_adblog_functionality(ad):
@@ -1560,7 +1702,7 @@
def check_chipset_vendor_by_qualcomm(ad):
- """Check if cipset vendor is by Qualcomm.
+ """Check if chipset vendor is by Qualcomm.
Args:
ad: An AndroidDevice object.
@@ -1598,14 +1740,14 @@
"NORMAL_PSDS_SERVER",
"REALTIME_PSDS_SERVER"]
delete_lto_file(ad)
- tmp_path = tempfile.mkdtemp()
- ad.pull_files("/etc/gps_debug.conf", tmp_path)
- gps_conf_path = os.path.join(tmp_path, "gps_debug.conf")
- gps_conf_file = open(gps_conf_path, "r")
- lines = gps_conf_file.readlines()
- gps_conf_file.close()
- fout = open(gps_conf_path, "w")
if state:
+ tmp_path = tempfile.mkdtemp()
+ ad.pull_files("/etc/gps_debug.conf", tmp_path)
+ gps_conf_path = os.path.join(tmp_path, "gps_debug.conf")
+ gps_conf_file = open(gps_conf_path, "r")
+ lines = gps_conf_file.readlines()
+ gps_conf_file.close()
+ fout = open(gps_conf_path, "w")
for line in lines:
for server in server_list:
if server in line:
@@ -1615,6 +1757,7 @@
ad.push_system_file(gps_conf_path, "/etc/gps_debug.conf")
ad.log.info("Push back modified gps_debug.conf")
ad.log.info("LTO/RTO/RTI enabled")
+ shutil.rmtree(tmp_path, ignore_errors=True)
else:
ad.adb.shell("echo %r >> /etc/gps_debug.conf" %
DISABLE_LTO_FILE_CONTENTS)
@@ -1622,6 +1765,78 @@
reboot(ad)
+def lto_mode_wearable(ad, state):
+ """Enable or Disable LTO mode for wearable in Android R release.
+
+ Args:
+ ad: An AndroidDevice object.
+ state: True to enable. False to disable.
+ """
+ rto_enable = ' RtoEnable="true"\n'
+ rto_disable = ' RtoEnable="false"\n'
+ rti_enable = ' RtiEnable="true"\n'
+ rti_disable = ' RtiEnable="false"\n'
+ sync_lto_enable = ' HttpDirectSyncLto="true"\n'
+ sync_lto_disable = ' HttpDirectSyncLto="false"\n'
+ server_list = ["XTRA_SERVER_1", "XTRA_SERVER_2", "XTRA_SERVER_3"]
+ delete_lto_file(ad)
+ tmp_path = tempfile.mkdtemp()
+ ad.pull_files("/vendor/etc/gnss/gps.xml", tmp_path)
+ gps_xml_path = os.path.join(tmp_path, "gps.xml")
+ gps_xml_file = open(gps_xml_path, "r")
+ lines = gps_xml_file.readlines()
+ gps_xml_file.close()
+ fout = open(gps_xml_path, "w")
+ for line in lines:
+ if state:
+ if rto_disable in line:
+ line = line.replace(line, rto_enable)
+ ad.log.info("RTO enabled")
+ elif rti_disable in line:
+ line = line.replace(line, rti_enable)
+ ad.log.info("RTI enabled")
+ elif sync_lto_disable in line:
+ line = line.replace(line, sync_lto_enable)
+ ad.log.info("LTO sync enabled")
+ else:
+ if rto_enable in line:
+ line = line.replace(line, rto_disable)
+ ad.log.info("RTO disabled")
+ elif rti_enable in line:
+ line = line.replace(line, rti_disable)
+ ad.log.info("RTI disabled")
+ elif sync_lto_enable in line:
+ line = line.replace(line, sync_lto_disable)
+ ad.log.info("LTO sync disabled")
+ fout.write(line)
+ fout.close()
+ ad.push_system_file(gps_xml_path, "/vendor/etc/gnss/gps.xml")
+ ad.log.info("Push back modified gps.xml")
+ shutil.rmtree(tmp_path, ignore_errors=True)
+ if state:
+ xtra_tmp_path = tempfile.mkdtemp()
+ ad.pull_files("/etc/gps_debug.conf", xtra_tmp_path)
+ gps_conf_path = os.path.join(xtra_tmp_path, "gps_debug.conf")
+ gps_conf_file = open(gps_conf_path, "r")
+ lines = gps_conf_file.readlines()
+ gps_conf_file.close()
+ fout = open(gps_conf_path, "w")
+ for line in lines:
+ for server in server_list:
+ if server in line:
+ line = line.replace(line, "")
+ fout.write(line)
+ fout.close()
+ ad.push_system_file(gps_conf_path, "/etc/gps_debug.conf")
+ ad.log.info("Push back modified gps_debug.conf")
+ ad.log.info("LTO/RTO/RTI enabled")
+ shutil.rmtree(xtra_tmp_path, ignore_errors=True)
+ else:
+ ad.adb.shell(
+ "echo %r >> /etc/gps_debug.conf" % DISABLE_LTO_FILE_CONTENTS_R)
+ ad.log.info("LTO/RTO/RTI disabled")
+
+
def start_pixel_logger(ad, max_log_size_mb=100, max_number_of_files=500):
"""adb to start pixel logger for GNSS logging.
@@ -1635,31 +1850,35 @@
start_timeout_sec = 60
default_gnss_cfg = "/vendor/etc/mdlog/DEFAULT+SECURITY+FULLDPL+GPS.cfg"
if check_chipset_vendor_by_qualcomm(ad):
- start_cmd = ("am start-foreground-service -a com.android.pixellogger"
- ".service.logging.LoggingService.ACTION_START_LOGGING "
+ start_cmd = ("am startservice -a com.android.pixellogger."
+ "service.logging.LoggingService.ACTION_START_LOGGING "
"-e intent_key_cfg_path '%s' "
"--ei intent_key_max_log_size_mb %d "
- "--ei intent_key_max_number_of_files %d" % (
- default_gnss_cfg, max_log_size_mb, max_number_of_files))
+ "--ei intent_key_max_number_of_files %d" %
+ (default_gnss_cfg, max_log_size_mb, max_number_of_files))
else:
start_cmd = ("am startservice -a com.android.pixellogger."
"service.logging.LoggingService.ACTION_START_LOGGING "
- "-e intent_logger brcm_gps")
+ "-e intent_logger brcm_gps "
+ "--ei intent_key_max_log_size_mb %d "
+ "--ei intent_key_max_number_of_files %d" %
+ (max_log_size_mb, max_number_of_files))
for attempt in range(retries):
- begin_time = get_current_epoch_time()
- ad.log.info("Start Pixel Logger. - Attempt %d" % (attempt + 1))
+ begin_time = get_current_epoch_time() - 3000
+ ad.log.info("Start Pixel Logger - Attempt %d" % (attempt + 1))
ad.adb.shell(start_cmd)
while get_current_epoch_time() - begin_time <= start_timeout_sec * 1000:
if not ad.is_adb_logcat_on:
ad.start_adb_logcat()
if check_chipset_vendor_by_qualcomm(ad):
- start_result = ad.search_logcat("Start logging", begin_time)
+ start_result = ad.search_logcat(
+ "ModemLogger: Start logging", begin_time)
else:
start_result = ad.search_logcat("startRecording", begin_time)
if start_result:
ad.log.info("Pixel Logger starts recording successfully.")
return True
- ad.force_stop_apk("com.android.pixellogger")
+ stop_pixel_logger(ad)
else:
ad.log.warn("Pixel Logger fails to start recording in %d seconds "
"within %d attempts." % (start_timeout_sec, retries))
@@ -1672,17 +1891,18 @@
ad: An AndroidDevice object.
"""
retries = 3
- stop_timeout_sec = 300
+ stop_timeout_sec = 60
+ zip_timeout_sec = 30
if check_chipset_vendor_by_qualcomm(ad):
- stop_cmd = ("am start-foreground-service -a com.android.pixellogger"
- ".service.logging.LoggingService.ACTION_STOP_LOGGING")
+ stop_cmd = ("am startservice -a com.android.pixellogger."
+ "service.logging.LoggingService.ACTION_STOP_LOGGING")
else:
stop_cmd = ("am startservice -a com.android.pixellogger."
"service.logging.LoggingService.ACTION_STOP_LOGGING "
"-e intent_logger brcm_gps")
for attempt in range(retries):
- begin_time = get_current_epoch_time()
- ad.log.info("Stop Pixel Logger. - Attempt %d" % (attempt + 1))
+ begin_time = get_current_epoch_time() - 3000
+ ad.log.info("Stop Pixel Logger - Attempt %d" % (attempt + 1))
ad.adb.shell(stop_cmd)
while get_current_epoch_time() - begin_time <= stop_timeout_sec * 1000:
if not ad.is_adb_logcat_on:
@@ -1691,7 +1911,17 @@
"LoggingService: Stopping service", begin_time)
if stop_result:
ad.log.info("Pixel Logger stops successfully.")
- return True
+ zip_end_time = time.time() + zip_timeout_sec
+ while time.time() < zip_end_time:
+ zip_file_created = ad.search_logcat(
+ "FileUtil: Zip file has been created", begin_time)
+ if zip_file_created:
+ ad.log.info("Pixel Logger created zip file "
+ "successfully.")
+ return True
+ else:
+ ad.log.warn("Pixel Logger failed to create zip file.")
+ return False
ad.force_stop_apk("com.android.pixellogger")
else:
ad.log.warn("Pixel Logger fails to stop in %d seconds within %d "
@@ -1699,10 +1929,12 @@
def launch_eecoexer(ad):
- """adb to stop pixel logger for GNSS logging.
+ """Launch EEcoexer.
Args:
ad: An AndroidDevice object.
+ Raise:
+ signals.TestError if DUT fails to launch EEcoexer
"""
launch_cmd = ("am start -a android.intent.action.MAIN -n"
"com.google.eecoexer"
@@ -1716,20 +1948,26 @@
def excute_eecoexer_function(ad, eecoexer_args):
- """adb to stop pixel logger for GNSS logging.
+ """Execute EEcoexer commands.
Args:
ad: An AndroidDevice object.
eecoexer_args: EEcoexer function arguments
"""
+ cat_index = eecoexer_args.split(',')[:2]
+ cat_index = ','.join(cat_index)
enqueue_cmd = ("am broadcast -a com.google.eecoexer.action.LISTENER"
" --es sms_body ENQUEUE,{}".format(eecoexer_args))
exe_cmd = ("am broadcast -a com.google.eecoexer.action.LISTENER"
" --es sms_body EXECUTE")
+ wait_for_cmd = ("am broadcast -a com.google.eecoexer.action.LISTENER"
+ " --es sms_body WAIT_FOR_COMPLETE,{}".format(cat_index))
ad.log.info("EEcoexer Add Enqueue: {}".format(eecoexer_args))
ad.adb.shell(enqueue_cmd)
ad.log.info("EEcoexer Excute.")
ad.adb.shell(exe_cmd)
+ ad.log.info("Wait EEcoexer for complete")
+ ad.adb.shell(wait_for_cmd)
def restart_gps_daemons(ad):
@@ -1756,3 +1994,490 @@
break
else:
raise signals.TestError("Unable to restart \"%s\"" % service)
+
+
+def is_device_wearable(ad):
+ """Check device is wearable project or not.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ package = ad.adb.getprop("ro.cw.home_package_names")
+ ad.log.debug("[ro.cw.home_package_names]: [%s]" % package)
+ return "wearable" in package
+
+
+def is_mobile_data_on(ad):
+ """Check if mobile data of device is on.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ if is_device_wearable(ad):
+ cell_on = ad.adb.shell("settings get global cell_on")
+ ad.log.debug("Current mobile status is %s" % cell_on)
+ return "1" in cell_on
+ else:
+ return ad.droid.telephonyIsDataEnabled()
+
+
+def human_to_epoch_time(human_time):
+ """Convert human readable time to epoch time.
+
+ Args:
+ human_time: Human readable time. (Ex: 2020-08-04 13:24:28.900)
+
+ Returns:
+ epoch: Epoch time in milliseconds.
+ """
+ if "/" in human_time:
+ human_time.replace("/", "-")
+ try:
+ epoch_start = datetime.utcfromtimestamp(0)
+ if "." in human_time:
+ epoch_time = datetime.strptime(human_time, "%Y-%m-%d %H:%M:%S.%f")
+ else:
+ epoch_time = datetime.strptime(human_time, "%Y-%m-%d %H:%M:%S")
+ epoch = int((epoch_time - epoch_start).total_seconds() * 1000)
+ return epoch
+ except ValueError:
+ return None
+
+
+def check_dpo_rate_via_gnss_meas(ad, begin_time, dpo_threshold):
+ """Check DPO engage rate through "HardwareClockDiscontinuityCount" in
+ GnssMeasurement callback.
+
+ Args:
+ ad: An AndroidDevice object.
+ begin_time: test begin time.
+ 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.")
+ ad.log.info(dpo_results[0]["log_message"])
+ ad.log.info(dpo_results[-1]["log_message"])
+ start_time = re.compile(
+ time_regex).search(dpo_results[0]["log_message"]).group(1)
+ end_time = re.compile(
+ time_regex).search(dpo_results[-1]["log_message"]).group(1)
+ gnss_start_epoch = human_to_epoch_time(start_time)
+ gnss_stop_epoch = human_to_epoch_time(end_time)
+ test_time_in_sec = round((gnss_stop_epoch - gnss_start_epoch) / 1000) + 1
+ first_dpo_count = int(dpo_results[0]["log_message"].split()[-1])
+ final_dpo_count = int(dpo_results[-1]["log_message"].split()[-1])
+ dpo_rate = ((final_dpo_count - first_dpo_count)/test_time_in_sec)
+ dpo_engage_rate = "{percent:.2%}".format(percent=dpo_rate)
+ ad.log.info("DPO is ON for %d seconds during %d seconds test." % (
+ final_dpo_count - first_dpo_count, test_time_in_sec))
+ ad.log.info("TestResult DPO_Engage_Rate " + dpo_engage_rate)
+ threshold = "{percent:.0%}".format(percent=dpo_threshold / 100)
+ asserts.assert_true(dpo_rate * 100 > dpo_threshold,
+ "DPO only engaged %s in %d seconds test with "
+ "threshold %s." % (dpo_engage_rate,
+ test_time_in_sec,
+ threshold))
+
+
+def parse_brcm_nmea_log(ad, nmea_pattern, brcm_error_log_allowlist):
+ """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.
+
+ Returns:
+ brcm_log_list: A list of specific NMEA pattern logs.
+ """
+ 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)
+ brcm_error_log = "".join(brcm_error_log_list)
+ shutil.rmtree(tmp_log_path, ignore_errors=True)
+ return brcm_log_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.
+ F - Enabled, now in full power mode.
+ S - Enabled, now in power save mode.
+ H - Host off load mode.
+
+ Args:
+ ad: An AndroidDevice object.
+ dpo_threshold: The value to set threshold. (Ex: dpo_threshold = 60)
+ brcm_error_log_allowlist: Benign error logs to exclude.
+ """
+ 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")
+
+ for pglor in pglor_list:
+ power_res = re.compile(r',P,(\w),').search(pglor).group(1)
+ if power_res == "D":
+ always_full_power_count += 1
+ elif power_res == "F":
+ full_power_count += 1
+ elif power_res == "S":
+ power_save_count += 1
+ ad.log.info(sorted(pglor_list)[0])
+ ad.log.info(sorted(pglor_list)[-1])
+ ad.log.info("TestResult Total_Count %d" % len(pglor_list))
+ ad.log.info("TestResult Always_Full_Power_Count %d" %
+ always_full_power_count)
+ ad.log.info("TestResult Full_Power_Mode_Count %d" % full_power_count)
+ ad.log.info("TestResult Power_Save_Mode_Count %d" % power_save_count)
+ dpo_rate = (power_save_count / len(pglor_list))
+ dpo_engage_rate = "{percent:.2%}".format(percent=dpo_rate)
+ ad.log.info("Power Save Mode is ON for %d seconds during %d seconds test."
+ % (power_save_count, len(pglor_list)))
+ ad.log.info("TestResult DPO_Engage_Rate " + dpo_engage_rate)
+ threshold = "{percent:.0%}".format(percent=dpo_threshold / 100)
+ asserts.assert_true((dpo_rate * 100 > dpo_threshold) and not brcm_error_log,
+ "Power Save Mode only engaged %s in %d seconds test "
+ "with threshold %s.\nAbnormal behavior found as below."
+ "\n%s" % (dpo_engage_rate,
+ len(pglor_list),
+ threshold,
+ brcm_error_log))
+
+
+def pair_to_wearable(ad, ad1):
+ """Pair phone to watch via Bluetooth.
+
+ Args:
+ ad: A pixel phone.
+ ad1: A wearable project.
+ """
+ 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")
+ 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.")
+ time.sleep(60)
+ ad.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/"
+ "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.")
+ 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.")
+
+
+def is_bluetooth_connected(ad, ad1):
+ """Check if device's Bluetooth status is connected or not.
+
+ Args:
+ ad: A wearable project
+ ad1: A pixel phone.
+ """
+ return ad.droid.bluetoothIsDeviceConnected(ad1.droid.bluetoothGetLocalAddress())
+
+
+def detect_crash_during_tracking(ad, begin_time, type):
+ """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.
+ """
+ gnss_crash_list = [".*Fatal signal.*gnss",
+ ".*Fatal signal.*xtra",
+ ".*F DEBUG.*gnss",
+ ".*Fatal signal.*gpsd"]
+ 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)
+ if gnss_crash_result:
+ start_gnss_by_gtw_gpstool(ad, state=False, type=type)
+ raise signals.TestFailure(
+ "Test failed due to GNSS HAL crashed. \n%s" %
+ gnss_crash_result)
+ gpstool_crash_result = ad.search_logcat("Force finishing activity "
+ "com.android.gpstool/.GPSTool",
+ begin_time)
+ if gpstool_crash_result:
+ raise signals.TestError("GPSTool crashed. Abort test.")
+
+
+def is_wearable_btwifi(ad):
+ """Check device is wearable btwifi sku or not.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ package = ad.adb.getprop("ro.product.product.name")
+ ad.log.debug("[ro.product.product.name]: [%s]" % package)
+ return "btwifi" in package
+
+
+def compare_watch_phone_location(ad,watch_file, phone_file):
+ """Compare watch and phone's FLP location to see if the same or not.
+
+ Args:
+ ad: An AndroidDevice object.
+ watch_file: watch's FLP locations
+ phone_file: phone's FLP locations
+ """
+ not_match_location_counts = 0
+ not_match_location = []
+ for watch_key, watch_value in watch_file.items():
+ if phone_file.get(watch_key):
+ lat_ads = abs(float(watch_value[0]) - float(phone_file[watch_key][0]))
+ lon_ads = abs(float(watch_value[1]) - float(phone_file[watch_key][1]))
+ if lat_ads > 0.000002 or lon_ads > 0.000002:
+ not_match_location_counts += 1
+ not_match_location += (watch_key, watch_value, phone_file[watch_key])
+ if not_match_location_counts > 0:
+ ad.log.info("There are %s not match locations: %s" %(not_match_location_counts, not_match_location))
+ ad.log.info("Watch's locations are not using Phone's locations.")
+ return False
+ else:
+ ad.log.info("Watch's locations are using Phone's location.")
+ return True
+
+
+def check_tracking_file(ad):
+ """Check tracking file in device and save "Latitude", "Longitude", and "Time" information.
+
+ Args:
+ ad: An AndroidDevice object.
+
+ Returns:
+ location_reports: A dict with [latitude, longitude]
+ """
+ location_reports = dict()
+ test_logfile = {}
+ 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()
+ for path_key in dir_file:
+ if fnmatch.fnmatch(path_key, "*.txt"):
+ logpath = posixpath.join(GNSSSTATUS_LOG_PATH, path_key)
+ out = ad.adb.shell("wc -c %s" % logpath)
+ file_size = int(out.split(" ")[0])
+ if file_size < 10:
+ ad.log.info("Skip log %s due to log size %d bytes" %
+ (path_key, file_size))
+ continue
+ test_logfile = logpath
+ 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")
+ for file_data in lines:
+ if "Latitude:" in file_data:
+ file_lat = ("%.6f" %float(file_data[9:]))
+ elif "Longitude:" in file_data:
+ file_long = ("%.6f" %float(file_data[11:]))
+ elif "Time:" in file_data:
+ file_time = (file_data[17:25])
+ location_reports[file_time] = [file_lat, file_long]
+ return location_reports
+
+
+def uia_click(ad, matching_text):
+ """Use uiautomator to click objects.
+
+ Args:
+ ad: An AndroidDevice object.
+ matching_text: Text of the target object to click
+ """
+ if ad.uia(textMatches=matching_text).wait.exists(timeout=60000):
+
+ ad.uia(textMatches=matching_text).click()
+ ad.log.info("Click button %s" % matching_text)
+ else:
+ ad.log.error("No button named %s" % matching_text)
+
+
+def delete_bcm_nvmem_sto_file(ad):
+ """Delete BCM's NVMEM ephemeris gldata.sto.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ remount_device(ad)
+ rm_cmd = "rm -rf {}".format(BCM_NVME_STO_PATH)
+ status = ad.adb.shell(rm_cmd)
+ ad.log.info("Delete BCM's NVMEM ephemeris files.\n%s" % status)
+
+
+def bcm_gps_xml_add_option(ad,
+ search_line=None,
+ append_txt=None,
+ gps_xml_path=BCM_GPS_XML_PATH):
+ """Append parameter setting in gps.xml for BCM solution
+
+ Args:
+ 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.
+ 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()
+ for line in lines:
+ if append_txt_tag in line:
+ 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()
+
+ # 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)
+
+
+def bcm_gps_ignore_rom_alm(ad):
+ """ Update BCM gps.xml with ignoreRomAlm="True"
+ Args:
+ ad: An AndroidDevice object.
+ """
+ search_line_tag = '<gll\n'
+ append_line_str = ' IgnoreRomAlm=\"true\"\n'
+ bcm_gps_xml_add_option(ad, search_line_tag, append_line_str)
+
+
+def check_inject_time(ad):
+ """Check if watch could get the UTC time.
+
+ Args:
+ ad: An AndroidDevice object.
+ """
+ for i in range(1, 6):
+ time.sleep(10)
+ inject_time_results = ad.search_logcat("GPSIC.OUT.gps_inject_time")
+ ad.log.info("Check time injected - attempt %s" % i)
+ if inject_time_results:
+ ad.log.info("Time is injected successfully.")
+ return True
+ raise signals.TestFailure("Fail to get time injected within %s attempts." % i)
+
+
+def enable_framework_log(ad):
+ """Enable framework log for wearable to check UTC time download.
+
+ 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)
diff --git a/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py b/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
index bf653af..11094fb 100644
--- a/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/power/PowerBaseTest.py
@@ -21,6 +21,7 @@
import time
import acts.controllers.power_monitor as power_monitor_lib
+import acts.controllers.monsoon as monsoon_controller
import acts.controllers.iperf_server as ipf
from acts import asserts
from acts import base_test
@@ -105,7 +106,14 @@
Raises an exception if there are no controllers available.
"""
- if hasattr(self, 'monsoons'):
+ if hasattr(self, 'bitses'):
+ if hasattr(self, 'monsoons'):
+ self.log.info('Destroying monsoon controller.')
+ monsoon_controller.destroy(self.monsoons)
+ time.sleep(2)
+ self.power_monitor = self.bitses[0]
+ self.power_monitor.setup(registry=self.user_params)
+ elif hasattr(self, 'monsoons'):
self.power_monitor = power_monitor_lib.PowerMonitorMonsoonFacade(
self.monsoons[0])
self.monsoons[0].set_max_current(8.0)
@@ -141,7 +149,8 @@
extra_wait=None,
iperf_duration=None,
pass_fail_tolerance=THRESHOLD_TOLERANCE_DEFAULT,
- mon_voltage=PHONE_BATTERY_VOLTAGE_DEFAULT)
+ mon_voltage=PHONE_BATTERY_VOLTAGE_DEFAULT,
+ ap_dtim_period=None)
# Setup the must have controllers, phone and monsoon
self.dut = self.android_devices[0]
diff --git a/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py b/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
index 3f8fd3a..baedb7e 100644
--- a/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/power/PowerGTWGnssBaseTest.py
@@ -92,6 +92,7 @@
lowpower: a boolean to set GNSS Low Power Mode.
meas: a boolean to set GNSS Measurement registeration.
"""
+ c_power, c_tracking, c_acquisition = self.request_power_stat()
self.ad.adb.shell('settings put secure location_mode 3')
gutils.start_gnss_by_gtw_gpstool(self.ad, True, 'gnss', True, freq,
lowpower, meas)
@@ -106,6 +107,10 @@
self.ad.send_keycode('WAKEUP')
gutils.start_gnss_by_gtw_gpstool(self.ad, False, 'gnss')
+ n_power, n_tracking, n_acquisition = self.request_power_stat()
+ self.ad.log.info("TestResult Total_power: %.2f" %(n_power - c_power))
+ self.ad.log.info("TestResult Tracking: %.2f" %(n_tracking - c_tracking))
+ self.ad.log.info("TestResult Acquisition: %.2f" %(n_acquisition - c_acquisition))
gutils.parse_gtw_gpstool_log(self.ad, self.test_location, type='gnss')
def calibrate_avg_current(self, samples):
@@ -139,3 +144,33 @@
self.ad.log.info(result)
raise signals.TestFailure('DPO is not able to Turn: %s' % enable)
self.dut_rockbottom()
+
+ def request_power_stat(self):
+ """Request the power state via command.
+ Returns:
+ total_power, tracking, acquisition power consumption.
+ If the device does not support, return 0, 0, 0
+ """
+ self.ad.adb.shell('cmd location providers send-extra-command gps request_power_stats')
+ time.sleep(1)
+ res = self.ad.adb.shell('dumpsys location | grep -A 10 -i \'power stats\'')
+ if res:
+ for line in res.split("\n"):
+ if "total power" in line:
+ total_power = line.split(" ")[-1].split("mJ")[0]
+ if "single-band tracking" in line:
+ single_tracking = line.split(" ")[-1].split("mJ")[0]
+ self.ad.log.info(single_tracking)
+ if "multi-band tracking" in line:
+ multi_tracking = line.split(" ")[-1].split("mJ")[0]
+ if "single-band acquisition" in line:
+ single_acquisition = line.split(" ")[-1].split("mJ")[0]
+ if "multi-band acquisition" in line:
+ multi_acquisition = line.split(" ")[-1].split("mJ")[0]
+ tracking = float(single_tracking) + float(multi_tracking)
+ acquisition = float(single_acquisition) + float(multi_acquisition)
+ self.ad.log.info("total power: %.2f" %float(total_power))
+ self.ad.log.info("tracking: %.2f" %tracking)
+ self.ad.log.info("acquisition: %.2f" %acquisition)
+ return float(total_power), tracking, acquisition
+ return 0, 0, 0
diff --git a/acts_tests/acts_contrib/test_utils/power/PowerWiFiBaseTest.py b/acts_tests/acts_contrib/test_utils/power/PowerWiFiBaseTest.py
index b57a06e..4a93afb 100644
--- a/acts_tests/acts_contrib/test_utils/power/PowerWiFiBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/power/PowerWiFiBaseTest.py
@@ -49,7 +49,7 @@
self.iperf_server = self.iperf_servers[0]
if self.iperf_duration:
self.mon_duration = self.iperf_duration - self.mon_offset - IPERF_TAIL
- self.create_monsoon_info()
+ self.mon_info = self.create_monsoon_info()
wutils.set_wifi_country_code(self.dut, 'US')
@@ -120,7 +120,8 @@
network,
bandwidth=80,
connect=True,
- ap=None):
+ ap=None,
+ dtim_period=None):
"""Setup AP and connect DUT to it.
Args:
@@ -128,17 +129,23 @@
bandwidth: bandwidth of the WiFi network to be setup
connect: indicator of if connect dut to the network after setup
ap: access point object, default is None to find the main AP
+ dtim_period: the dtim period of access point
Returns:
self.brconfigs: dict for bridge interface configs
"""
wutils.wifi_toggle_state(self.dut, True)
+ if not dtim_period:
+ dtim_period = self.ap_dtim_period
if not ap:
if hasattr(self, 'access_points'):
- self.brconfigs = wputils.ap_setup(self.access_point,
- network,
- bandwidth=bandwidth)
+ self.brconfigs = wputils.ap_setup(
+ self.access_point,
+ network,
+ bandwidth=bandwidth,
+ dtim_period=dtim_period)
else:
- self.brconfigs = wputils.ap_setup(ap, network, bandwidth=bandwidth)
+ self.brconfigs = wputils.ap_setup(
+ ap, network, bandwidth=bandwidth, dtim_period=dtim_period)
if connect:
wutils.wifi_connect(self.dut, network, num_of_tries=3)
@@ -154,9 +161,12 @@
tag = ''
if self.iperf_duration:
throughput = self.process_iperf_results()
- plot_title = '{}_{}_{}_RSSI_{0:d}dBm_Throughput_{1:.2f}Mbps'.format(
- self.test_name, self.dut.model,
- self.dut.build_info['build_id'], self.RSSI, throughput)
+ plot_title = ('{0}_{1}_{2}_RSSI_{3:d}dBm_Throughput_{4:.2f}'
+ 'Mbps'.format(self.test_name,
+ self.dut.model,
+ self.dut.build_info['build_id'],
+ self.RSSI,
+ throughput))
plot_utils.current_waveform_plot(samples, self.mon_voltage,
self.mon_info.data_path,
plot_title)
diff --git a/acts_tests/acts_contrib/test_utils/power/plot_utils.py b/acts_tests/acts_contrib/test_utils/power/plot_utils.py
index b2a42ab..99d22ac 100644
--- a/acts_tests/acts_contrib/test_utils/power/plot_utils.py
+++ b/acts_tests/acts_contrib/test_utils/power/plot_utils.py
@@ -14,16 +14,18 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os
+import datetime
import logging
-import numpy
import math
+import numpy
+import os
-from bokeh.layouts import layout
-from bokeh.models import CustomJS, ColumnDataSource
from bokeh.models import tools as bokeh_tools
+from bokeh.models import CustomJS, ColumnDataSource
from bokeh.models.widgets import DataTable, TableColumn
+from bokeh.models.formatters import DatetimeTickFormatter
from bokeh.plotting import figure, output_file, save
+from bokeh.layouts import layout
def current_waveform_plot(samples, voltage, dest_path, plot_title):
@@ -48,16 +50,17 @@
"""
logging.info('Plotting the power measurement data.')
- time_relative = [sample[0] for sample in samples]
- duration = time_relative[-1] - time_relative[0]
+ duration = samples[-1][0] - samples[0][0]
current_data = [sample[1] * 1000 for sample in samples]
avg_current = sum(current_data) / len(current_data)
-
color = ['navy'] * len(samples)
+ time_realtime = [
+ datetime.datetime.fromtimestamp(sample[0]) for sample in samples
+ ]
# Preparing the data and source link for bokehn java callback
source = ColumnDataSource(
- data=dict(x=time_relative, y=current_data, color=color))
+ data=dict(x=time_realtime, y=current_data, color=color))
s2 = ColumnDataSource(
data=dict(a=[duration],
b=[round(avg_current, 2)],
@@ -81,7 +84,8 @@
output_file(os.path.join(dest_path, plot_title + '.html'))
tools = 'box_zoom,box_select,pan,crosshair,redo,undo,reset,hover,save'
# Create a new plot with the datatable above
- plot = figure(plot_width=1300,
+ plot = figure(x_axis_type='datetime',
+ plot_width=1300,
plot_height=700,
title=plot_title,
tools=tools)
@@ -91,6 +95,13 @@
plot.circle('x', 'y', source=source, size=0.5, fill_color='color')
plot.xaxis.axis_label = 'Time (s)'
plot.yaxis.axis_label = 'Current (mA)'
+ plot.xaxis.formatter = DatetimeTickFormatter(
+ seconds=["%H:%M:%S"],
+ milliseconds=["%H:%M:%S:%3Ns"],
+ microseconds=["%H:%M:%S:%fus"],
+ minutes=["%H:%M:%S"],
+ minsec=["%H:%M:%S"],
+ hours=["%H:%M:%S"])
# Callback JavaScript
source.selected.js_on_change(
@@ -120,7 +131,7 @@
}
ym /= inds.length
ts = max - min
- d2['a'].push(Math.round(ts*1000.0)/1000.0)
+ d2['a'].push(Math.round(ts*1000.0)/1000000.0)
d2['b'].push(Math.round(ym*100.0)/100.0)
d2['c'].push(Math.round(ym*4.2*100.0)/100.0)
d2['d'].push(Math.round(ym*4.2*ts*100.0)/100.0)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/aware/AwareBaseTest.py b/acts_tests/acts_contrib/test_utils/wifi/aware/AwareBaseTest.py
index c0c1075..14c5c0e 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/aware/AwareBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/aware/AwareBaseTest.py
@@ -36,7 +36,7 @@
device_startup_offset = 2
def setup_class(self):
- opt_param = ["pixel_models", "cnss_diag_file"]
+ opt_param = ["pixel_models", "cnss_diag_file", "ranging_role_concurrency_flexible_models"]
self.unpack_userparams(opt_param_names=opt_param)
if hasattr(self, "cnss_diag_file"):
if isinstance(self.cnss_diag_file, list):
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 4274603..d74e785 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/ota_chamber.py
@@ -89,6 +89,7 @@
self.log = logger.create_tagged_trace_logger('OtaChamber|{}'.format(
self.device_id))
self.current_mode = None
+ self.SUPPORTED_BANDS = ['2.4GHz', 'UNII-1', 'UNII-2', 'UNII-3', '6GHz']
def set_orientation(self, orientation):
self.log.info('Setting orientation to {} degrees.'.format(orientation))
@@ -128,6 +129,7 @@
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']
def set_orientation(self, orientation):
self.log.info('Setting orientation to {} degrees.'.format(orientation))
@@ -165,6 +167,7 @@
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']
# Capture print output decorator
@staticmethod
@@ -248,8 +251,8 @@
def __init__(self, config):
self.config = config.copy()
self.device_id = self.config['device_id']
- self.log = logger.create_tagged_trace_logger('EInstrumentChamber|{}'.format(
- self.device_id))
+ self.log = logger.create_tagged_trace_logger(
+ 'EInstrumentChamber|{}'.format(self.device_id))
self.current_mode = None
self.ser = self._get_serial(config['port'])
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 a20936f..395fed2 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/ota_sniffer.py
@@ -136,7 +136,7 @@
network: dict of network credentials.
duration: duration of the sniff.
"""
- self.log.info('Starting sniffer.')
+ self.log.debug('Starting sniffer.')
def stop_capture(self):
"""Stops the sniffer.
@@ -145,7 +145,7 @@
log_file: name of processed sniffer.
"""
- self.log.info('Stopping sniffer.')
+ self.log.debug('Stopping sniffer.')
log_file = self._get_full_file_path()
with open(log_file, 'w') as file:
file.write('this is a sniffer dump.')
@@ -235,6 +235,7 @@
self.sniffer_output_file_type = config['output_file_type']
self.sniffer_snap_length = config['snap_length']
self.sniffer_interface = config['interface']
+ self.sniffer_disabled = False
#Logging into sniffer
self.log.info('Logging into sniffer.')
@@ -325,13 +326,13 @@
Args:
sniffer_command: sniffer command to execute.
"""
- self.log.info('Starting sniffer.')
+ self.log.debug('Starting sniffer.')
sniffer_job = self._sniffer_server.run_async(sniffer_command)
self.sniffer_proc_pid = sniffer_job.stdout
def _stop_tshark(self):
""" Stops the sniffer."""
- self.log.info('Stopping sniffer')
+ self.log.debug('Stopping sniffer')
# while loop to kill the sniffer process
stop_time = time.time() + SNIFFER_TIMEOUT
@@ -408,7 +409,7 @@
"""
# Checking for existing sniffer processes
if self._started:
- self.log.info('Sniffer already running')
+ self.log.debug('Sniffer already running')
return
# Configure sniffer
@@ -429,7 +430,7 @@
"""
# Checking if there is an ongoing sniffer capture
if not self._started:
- self.log.error('No sniffer process running')
+ self.log.debug('No sniffer process running')
return
# Killing sniffer process
self._stop_tshark()
@@ -495,6 +496,30 @@
# e.g. setting monitor mode (which will fail if above is not complete)
time.sleep(1)
+ def start_capture(self, network, chan, bw, duration=60):
+ """Starts sniffer capture on the specified machine.
+
+ Args:
+ network: dict describing network to sniff on.
+ duration: duration of sniff.
+ """
+ # If sniffer doesnt support the channel, return
+ if '6g' in str(chan):
+ self.log.debug('Channel not supported on sniffer')
+ return
+ # Checking for existing sniffer processes
+ if self._started:
+ self.log.debug('Sniffer already running')
+ return
+
+ # Configure sniffer
+ self._configure_sniffer(network, chan, bw)
+ tshark_command = self._get_tshark_command(duration)
+ sniffer_command = self._get_sniffer_command(tshark_command)
+
+ # Starting sniffer capture by executing tshark command
+ self._run_tshark(sniffer_command)
+
def set_monitor_mode(self, chan, bw):
"""Function to configure interface to monitor mode
diff --git a/acts_tests/acts_contrib/test_utils/wifi/rtt/RttBaseTest.py b/acts_tests/acts_contrib/test_utils/wifi/rtt/RttBaseTest.py
index bb58b02..c11f66a 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/rtt/RttBaseTest.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/rtt/RttBaseTest.py
@@ -29,7 +29,7 @@
class RttBaseTest(BaseTestClass):
def setup_class(self):
- opt_param = ["pixel_models", "cnss_diag_file"]
+ opt_param = ["pixel_models", "cnss_diag_file", "ranging_role_concurrency_flexible_models"]
self.unpack_userparams(opt_param_names=opt_param)
if hasattr(self, "cnss_diag_file"):
if isinstance(self.cnss_diag_file, list):
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils.py
deleted file mode 100644
index 8afe1d5..0000000
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils.py
+++ /dev/null
@@ -1,1718 +0,0 @@
-#!/usr/bin/env python3.4
-#
-# Copyright 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 bokeh, bokeh.plotting, bokeh.io
-import collections
-import hashlib
-import ipaddress
-import itertools
-import json
-import logging
-import math
-import os
-import re
-import statistics
-import time
-from acts.controllers.android_device import AndroidDevice
-from acts.controllers.utils_lib import ssh
-from acts import asserts
-from acts import utils
-from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
-from concurrent.futures import ThreadPoolExecutor
-
-SHORT_SLEEP = 1
-MED_SLEEP = 6
-TEST_TIMEOUT = 10
-STATION_DUMP = 'iw wlan0 station dump'
-SCAN = 'wpa_cli scan'
-SCAN_RESULTS = 'wpa_cli scan_results'
-SIGNAL_POLL = 'wpa_cli signal_poll'
-WPA_CLI_STATUS = 'wpa_cli status'
-DISCONNECTION_MESSAGE_BRCM = 'driver adapter not found'
-CONST_3dB = 3.01029995664
-RSSI_ERROR_VAL = float('nan')
-RTT_REGEX = re.compile(r'^\[(?P<timestamp>\S+)\] .*? time=(?P<rtt>\S+)')
-LOSS_REGEX = re.compile(r'(?P<loss>\S+)% packet loss')
-FW_REGEX = re.compile(r'FW:(?P<firmware>\S+) HW:')
-
-
-# Threading decorator
-def nonblocking(f):
- """Creates a decorator transforming function calls to non-blocking"""
- def wrap(*args, **kwargs):
- executor = ThreadPoolExecutor(max_workers=1)
- thread_future = executor.submit(f, *args, **kwargs)
- # Ensure resources are freed up when executor ruturns or raises
- executor.shutdown(wait=False)
- return thread_future
-
- return wrap
-
-
-# JSON serializer
-def serialize_dict(input_dict):
- """Function to serialize dicts to enable JSON output"""
- output_dict = collections.OrderedDict()
- for key, value in input_dict.items():
- output_dict[_serialize_value(key)] = _serialize_value(value)
- return output_dict
-
-
-def _serialize_value(value):
- """Function to recursively serialize dict entries to enable JSON output"""
- if isinstance(value, tuple):
- return str(value)
- if isinstance(value, list):
- return [_serialize_value(x) for x in value]
- elif isinstance(value, dict):
- return serialize_dict(value)
- else:
- return value
-
-
-# Miscellaneous Wifi Utilities
-def extract_sub_dict(full_dict, fields):
- sub_dict = collections.OrderedDict(
- (field, full_dict[field]) for field in fields)
- return sub_dict
-
-
-def validate_network(dut, ssid):
- """Check that DUT has a valid internet connection through expected SSID
-
- Args:
- dut: android device of interest
- ssid: expected ssid
- """
- current_network = dut.droid.wifiGetConnectionInfo()
- try:
- connected = wutils.validate_connection(dut) is not None
- except:
- connected = False
- if connected and current_network['SSID'] == ssid:
- return True
- else:
- return False
-
-
-def get_server_address(ssh_connection, dut_ip, subnet_mask):
- """Get server address on a specific subnet,
-
- This function retrieves the LAN or WAN IP of a remote machine used in
- testing. If subnet_mask is set to 'public' it returns a machines global ip,
- else it returns the ip belonging to the dut local network given the dut's
- ip and subnet mask.
-
- Args:
- ssh_connection: object representing server for which we want an ip
- dut_ip: string in ip address format, i.e., xxx.xxx.xxx.xxx
- subnet_mask: string representing subnet mask (public for global ip)
- """
- ifconfig_out = ssh_connection.run('ifconfig').stdout
- ip_list = re.findall('inet (?:addr:)?(\d+.\d+.\d+.\d+)', ifconfig_out)
- ip_list = [ipaddress.ip_address(ip) for ip in ip_list]
-
- if subnet_mask == 'public':
- for ip in ip_list:
- # is_global is not used to allow for CGNAT ips in 100.x.y.z range
- if not ip.is_private:
- return str(ip)
- else:
- dut_network = ipaddress.ip_network('{}/{}'.format(dut_ip, subnet_mask),
- strict=False)
- for ip in ip_list:
- if ip in dut_network:
- return str(ip)
- logging.error('No IP address found in requested subnet')
-
-
-# Plotting Utilities
-class BokehFigure():
- """Class enabling simplified Bokeh plotting."""
-
- COLORS = [
- 'black',
- 'blue',
- 'blueviolet',
- 'brown',
- 'burlywood',
- 'cadetblue',
- 'cornflowerblue',
- 'crimson',
- 'cyan',
- 'darkblue',
- 'darkgreen',
- 'darkmagenta',
- 'darkorange',
- 'darkred',
- 'deepskyblue',
- 'goldenrod',
- 'green',
- 'grey',
- 'indigo',
- 'navy',
- 'olive',
- 'orange',
- 'red',
- 'salmon',
- 'teal',
- 'yellow',
- ]
- MARKERS = [
- 'asterisk', 'circle', 'circle_cross', 'circle_x', 'cross', 'diamond',
- 'diamond_cross', 'hex', 'inverted_triangle', 'square', 'square_x',
- 'square_cross', 'triangle', 'x'
- ]
-
- TOOLS = ('box_zoom,box_select,pan,crosshair,redo,undo,reset,hover,save')
- TOOLTIPS = [
- ('index', '$index'),
- ('(x,y)', '($x, $y)'),
- ('info', '@hover_text'),
- ]
-
- def __init__(self,
- title=None,
- x_label=None,
- primary_y_label=None,
- secondary_y_label=None,
- height=700,
- width=1100,
- title_size='15pt',
- axis_label_size='12pt',
- json_file=None):
- if json_file:
- self.load_from_json(json_file)
- else:
- self.figure_data = []
- self.fig_property = {
- 'title': title,
- 'x_label': x_label,
- 'primary_y_label': primary_y_label,
- 'secondary_y_label': secondary_y_label,
- 'num_lines': 0,
- 'height': height,
- 'width': width,
- 'title_size': title_size,
- 'axis_label_size': axis_label_size
- }
-
- def init_plot(self):
- self.plot = bokeh.plotting.figure(
- sizing_mode='scale_both',
- plot_width=self.fig_property['width'],
- plot_height=self.fig_property['height'],
- title=self.fig_property['title'],
- tools=self.TOOLS,
- output_backend='webgl')
- self.plot.hover.tooltips = self.TOOLTIPS
- self.plot.add_tools(
- bokeh.models.tools.WheelZoomTool(dimensions='width'))
- self.plot.add_tools(
- bokeh.models.tools.WheelZoomTool(dimensions='height'))
-
- def _filter_line(self, x_data, y_data, hover_text=None):
- """Function to remove NaN points from bokeh plots."""
- x_data_filtered = []
- y_data_filtered = []
- hover_text_filtered = []
- for x, y, hover in itertools.zip_longest(x_data, y_data, hover_text):
- if not math.isnan(y):
- x_data_filtered.append(x)
- y_data_filtered.append(y)
- hover_text_filtered.append(hover)
- return x_data_filtered, y_data_filtered, hover_text_filtered
-
- def add_line(self,
- x_data,
- y_data,
- legend,
- hover_text=None,
- color=None,
- width=3,
- style='solid',
- marker=None,
- marker_size=10,
- shaded_region=None,
- y_axis='default'):
- """Function to add line to existing BokehFigure.
-
- Args:
- x_data: list containing x-axis values for line
- y_data: list containing y_axis values for line
- legend: string containing line title
- hover_text: text to display when hovering over lines
- color: string describing line color
- width: integer line width
- style: string describing line style, e.g, solid or dashed
- marker: string specifying line marker, e.g., cross
- shaded region: data describing shaded region to plot
- y_axis: identifier for y-axis to plot line against
- """
- if y_axis not in ['default', 'secondary']:
- raise ValueError('y_axis must be default or secondary')
- if color == None:
- color = self.COLORS[self.fig_property['num_lines'] %
- len(self.COLORS)]
- if style == 'dashed':
- style = [5, 5]
- if not hover_text:
- hover_text = ['y={}'.format(y) for y in y_data]
- x_data_filter, y_data_filter, hover_text_filter = self._filter_line(
- x_data, y_data, hover_text)
- self.figure_data.append({
- 'x_data': x_data_filter,
- 'y_data': y_data_filter,
- 'legend': legend,
- 'hover_text': hover_text_filter,
- 'color': color,
- 'width': width,
- 'style': style,
- 'marker': marker,
- 'marker_size': marker_size,
- 'shaded_region': shaded_region,
- 'y_axis': y_axis
- })
- self.fig_property['num_lines'] += 1
-
- def add_scatter(self,
- x_data,
- y_data,
- legend,
- hover_text=None,
- color=None,
- marker=None,
- marker_size=10,
- y_axis='default'):
- """Function to add line to existing BokehFigure.
-
- Args:
- x_data: list containing x-axis values for line
- y_data: list containing y_axis values for line
- legend: string containing line title
- hover_text: text to display when hovering over lines
- color: string describing line color
- marker: string specifying marker, e.g., cross
- y_axis: identifier for y-axis to plot line against
- """
- if y_axis not in ['default', 'secondary']:
- raise ValueError('y_axis must be default or secondary')
- if color == None:
- color = self.COLORS[self.fig_property['num_lines'] %
- len(self.COLORS)]
- if marker == None:
- marker = self.MARKERS[self.fig_property['num_lines'] %
- len(self.MARKERS)]
- if not hover_text:
- hover_text = ['y={}'.format(y) for y in y_data]
- self.figure_data.append({
- 'x_data': x_data,
- 'y_data': y_data,
- 'legend': legend,
- 'hover_text': hover_text,
- 'color': color,
- 'width': 0,
- 'style': 'solid',
- 'marker': marker,
- 'marker_size': marker_size,
- 'shaded_region': None,
- 'y_axis': y_axis
- })
- self.fig_property['num_lines'] += 1
-
- def generate_figure(self, output_file=None, save_json=True):
- """Function to generate and save BokehFigure.
-
- Args:
- output_file: string specifying output file path
- """
- self.init_plot()
- two_axes = False
- for line in self.figure_data:
- source = bokeh.models.ColumnDataSource(
- data=dict(x=line['x_data'],
- y=line['y_data'],
- hover_text=line['hover_text']))
- if line['width'] > 0:
- self.plot.line(x='x',
- y='y',
- legend_label=line['legend'],
- line_width=line['width'],
- color=line['color'],
- line_dash=line['style'],
- name=line['y_axis'],
- y_range_name=line['y_axis'],
- source=source)
- if line['shaded_region']:
- band_x = line['shaded_region']['x_vector']
- band_x.extend(line['shaded_region']['x_vector'][::-1])
- band_y = line['shaded_region']['lower_limit']
- band_y.extend(line['shaded_region']['upper_limit'][::-1])
- self.plot.patch(band_x,
- band_y,
- color='#7570B3',
- line_alpha=0.1,
- fill_alpha=0.1)
- if line['marker'] in self.MARKERS:
- marker_func = getattr(self.plot, line['marker'])
- marker_func(x='x',
- y='y',
- size=line['marker_size'],
- legend_label=line['legend'],
- line_color=line['color'],
- fill_color=line['color'],
- name=line['y_axis'],
- y_range_name=line['y_axis'],
- source=source)
- if line['y_axis'] == 'secondary':
- two_axes = True
-
- #x-axis formatting
- self.plot.xaxis.axis_label = self.fig_property['x_label']
- self.plot.x_range.range_padding = 0
- self.plot.xaxis[0].axis_label_text_font_size = self.fig_property[
- 'axis_label_size']
- #y-axis formatting
- self.plot.yaxis[0].axis_label = self.fig_property['primary_y_label']
- self.plot.yaxis[0].axis_label_text_font_size = self.fig_property[
- 'axis_label_size']
- self.plot.y_range = bokeh.models.DataRange1d(names=['default'])
- if two_axes and 'secondary' not in self.plot.extra_y_ranges:
- self.plot.extra_y_ranges = {
- 'secondary': bokeh.models.DataRange1d(names=['secondary'])
- }
- self.plot.add_layout(
- bokeh.models.LinearAxis(
- y_range_name='secondary',
- axis_label=self.fig_property['secondary_y_label'],
- axis_label_text_font_size=self.
- fig_property['axis_label_size']), 'right')
- # plot formatting
- self.plot.legend.location = 'top_right'
- self.plot.legend.click_policy = 'hide'
- self.plot.title.text_font_size = self.fig_property['title_size']
-
- if output_file is not None:
- self.save_figure(output_file, save_json)
- return self.plot
-
- def load_from_json(self, file_path):
- with open(file_path, 'r') as json_file:
- fig_dict = json.load(json_file)
- self.fig_property = fig_dict['fig_property']
- self.figure_data = fig_dict['figure_data']
-
- def _save_figure_json(self, output_file):
- """Function to save a json format of a figure"""
- figure_dict = collections.OrderedDict(fig_property=self.fig_property,
- 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)
-
- def save_figure(self, output_file, save_json=True):
- """Function to save BokehFigure.
-
- Args:
- output_file: string specifying output file path
- save_json: flag controlling json outputs
- """
- if save_json:
- self._save_figure_json(output_file)
- bokeh.io.output_file(output_file)
- bokeh.io.save(self.plot)
-
- @staticmethod
- def save_figures(figure_array, output_file_path, save_json=True):
- """Function to save list of BokehFigures in one file.
-
- Args:
- figure_array: list of BokehFigure object to be plotted
- output_file: string specifying output file path
- """
- for idx, figure in enumerate(figure_array):
- figure.generate_figure()
- if save_json:
- json_file_path = output_file_path.replace(
- '.html', '{}-plot_data.json'.format(idx))
- figure._save_figure_json(json_file_path)
- plot_array = [figure.plot for figure in figure_array]
- all_plots = bokeh.layouts.column(children=plot_array,
- sizing_mode='scale_width')
- bokeh.plotting.output_file(output_file_path)
- bokeh.plotting.save(all_plots)
-
-
-# Ping utilities
-class PingResult(object):
- """An object that contains the results of running ping command.
-
- Attributes:
- connected: True if a connection was made. False otherwise.
- packet_loss_percentage: The total percentage of packets lost.
- transmission_times: The list of PingTransmissionTimes containing the
- timestamps gathered for transmitted packets.
- rtts: An list-like object enumerating all round-trip-times of
- transmitted packets.
- timestamps: A list-like object enumerating the beginning timestamps of
- each packet transmission.
- ping_interarrivals: A list-like object enumerating the amount of time
- between the beginning of each subsequent transmission.
- """
- def __init__(self, ping_output):
- self.packet_loss_percentage = 100
- self.transmission_times = []
-
- self.rtts = _ListWrap(self.transmission_times, lambda entry: entry.rtt)
- self.timestamps = _ListWrap(self.transmission_times,
- lambda entry: entry.timestamp)
- self.ping_interarrivals = _PingInterarrivals(self.transmission_times)
-
- self.start_time = 0
- for line in ping_output:
- if 'loss' in line:
- match = re.search(LOSS_REGEX, line)
- self.packet_loss_percentage = float(match.group('loss'))
- if 'time=' in line:
- match = re.search(RTT_REGEX, line)
- if self.start_time == 0:
- self.start_time = float(match.group('timestamp'))
- self.transmission_times.append(
- PingTransmissionTimes(
- float(match.group('timestamp')) - self.start_time,
- float(match.group('rtt'))))
- self.connected = len(
- ping_output) > 1 and self.packet_loss_percentage < 100
-
- def __getitem__(self, item):
- if item == 'rtt':
- return self.rtts
- if item == 'connected':
- return self.connected
- if item == 'packet_loss_percentage':
- return self.packet_loss_percentage
- raise ValueError('Invalid key. Please use an attribute instead.')
-
- def as_dict(self):
- return {
- 'connected': 1 if self.connected else 0,
- 'rtt': list(self.rtts),
- 'time_stamp': list(self.timestamps),
- 'ping_interarrivals': list(self.ping_interarrivals),
- 'packet_loss_percentage': self.packet_loss_percentage
- }
-
-
-class PingTransmissionTimes(object):
- """A class that holds the timestamps for a packet sent via the ping command.
-
- Attributes:
- rtt: The round trip time for the packet sent.
- timestamp: The timestamp the packet started its trip.
- """
- def __init__(self, timestamp, rtt):
- self.rtt = rtt
- self.timestamp = timestamp
-
-
-class _ListWrap(object):
- """A convenient helper class for treating list iterators as native lists."""
- def __init__(self, wrapped_list, func):
- self.__wrapped_list = wrapped_list
- self.__func = func
-
- def __getitem__(self, key):
- return self.__func(self.__wrapped_list[key])
-
- def __iter__(self):
- for item in self.__wrapped_list:
- yield self.__func(item)
-
- def __len__(self):
- return len(self.__wrapped_list)
-
-
-class _PingInterarrivals(object):
- """A helper class for treating ping interarrivals as a native list."""
- def __init__(self, ping_entries):
- self.__ping_entries = ping_entries
-
- def __getitem__(self, key):
- return (self.__ping_entries[key + 1].timestamp -
- self.__ping_entries[key].timestamp)
-
- def __iter__(self):
- for index in range(len(self.__ping_entries) - 1):
- yield self[index]
-
- def __len__(self):
- return max(0, len(self.__ping_entries) - 1)
-
-
-def get_ping_stats(src_device, dest_address, ping_duration, ping_interval,
- ping_size):
- """Run ping to or from the DUT.
-
- The function computes either pings the DUT or pings a remote ip from
- DUT.
-
- Args:
- src_device: object representing device to ping from
- dest_address: ip address to ping
- ping_duration: timeout to set on the the ping process (in seconds)
- ping_interval: time between pings (in seconds)
- ping_size: size of ping packet payload
- Returns:
- ping_result: dict containing ping results and other meta data
- """
- ping_count = int(ping_duration / ping_interval)
- ping_deadline = int(ping_count * ping_interval) + 1
- ping_cmd_linux = 'ping -c {} -w {} -i {} -s {} -D'.format(
- ping_count,
- ping_deadline,
- ping_interval,
- ping_size,
- )
-
- ping_cmd_macos = 'ping -c {} -t {} -i {} -s {}'.format(
- ping_count,
- ping_deadline,
- ping_interval,
- ping_size,
- )
-
- if isinstance(src_device, AndroidDevice):
- ping_cmd = '{} {}'.format(ping_cmd_linux, dest_address)
- ping_output = src_device.adb.shell(ping_cmd,
- timeout=ping_deadline + SHORT_SLEEP,
- ignore_status=True)
- elif isinstance(src_device, ssh.connection.SshConnection):
- platform = src_device.run('uname').stdout
- if 'linux' in platform.lower():
- ping_cmd = 'sudo {} {}'.format(ping_cmd_linux, dest_address)
- elif 'darwin' in platform.lower():
- ping_cmd = "sudo {} {}| while IFS= read -r line; do printf '[%s] %s\n' \"$(gdate '+%s.%N')\" \"$line\"; done".format(
- ping_cmd_macos, dest_address)
- ping_output = src_device.run(ping_cmd,
- timeout=ping_deadline + SHORT_SLEEP,
- ignore_status=True).stdout
- else:
- raise TypeError('Unable to ping using src_device of type %s.' %
- type(src_device))
- return PingResult(ping_output.splitlines())
-
-
-@nonblocking
-def get_ping_stats_nb(src_device, dest_address, ping_duration, ping_interval,
- ping_size):
- return get_ping_stats(src_device, dest_address, ping_duration,
- ping_interval, ping_size)
-
-
-# Iperf utilities
-@nonblocking
-def start_iperf_client_nb(iperf_client, iperf_server_address, iperf_args, tag,
- timeout):
- return iperf_client.start(iperf_server_address, iperf_args, tag, timeout)
-
-
-def get_iperf_arg_string(duration,
- reverse_direction,
- interval=1,
- traffic_type='TCP',
- socket_size=None,
- num_processes=1,
- udp_throughput='1000M',
- ipv6=False):
- """Function to format iperf client arguments.
-
- This function takes in iperf client parameters and returns a properly
- formatter iperf arg string to be used in throughput tests.
-
- Args:
- duration: iperf duration in seconds
- reverse_direction: boolean controlling the -R flag for iperf clients
- interval: iperf print interval
- traffic_type: string specifying TCP or UDP traffic
- socket_size: string specifying TCP window or socket buffer, e.g., 2M
- num_processes: int specifying number of iperf processes
- udp_throughput: string specifying TX throughput in UDP tests, e.g. 100M
- ipv6: boolean controlling the use of IP V6
- Returns:
- iperf_args: string of formatted iperf args
- """
- iperf_args = '-i {} -t {} -J '.format(interval, duration)
- 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)
- elif traffic_type.upper() == 'TCP':
- iperf_args = iperf_args + '-P {} '.format(num_processes)
- if socket_size:
- iperf_args = iperf_args + '-w {} '.format(socket_size)
- if reverse_direction:
- iperf_args = iperf_args + ' -R'
- return iperf_args
-
-
-# Attenuator Utilities
-def atten_by_label(atten_list, path_label, atten_level):
- """Attenuate signals according to their path label.
-
- Args:
- atten_list: list of attenuators to iterate over
- path_label: path label on which to set desired attenuation
- atten_level: attenuation desired on path
- """
- for atten in atten_list:
- if path_label in atten.path:
- atten.set_atten(atten_level, retry=True)
-
-
-def get_atten_for_target_rssi(target_rssi, attenuators, dut, ping_server):
- """Function to estimate attenuation to hit a target RSSI.
-
- This function estimates a constant attenuation setting on all atennuation
- ports to hit a target RSSI. The estimate is not meant to be exact or
- guaranteed.
-
- Args:
- target_rssi: rssi of interest
- attenuators: list of attenuator ports
- dut: android device object assumed connected to a wifi network.
- ping_server: ssh connection object to ping server
- Returns:
- target_atten: attenuation setting to achieve target_rssi
- """
- logging.info('Searching attenuation for RSSI = {}dB'.format(target_rssi))
- # Set attenuator to 0 dB
- for atten in attenuators:
- atten.set_atten(0, strict=False, retry=True)
- # Start ping traffic
- dut_ip = dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
- # Measure starting RSSI
- ping_future = get_ping_stats_nb(src_device=ping_server,
- dest_address=dut_ip,
- ping_duration=1.5,
- ping_interval=0.02,
- ping_size=64)
- current_rssi = get_connected_rssi(dut,
- num_measurements=4,
- polling_frequency=0.25,
- first_measurement_delay=0.5,
- disconnect_warning=1,
- ignore_samples=1)
- current_rssi = current_rssi['signal_poll_rssi']['mean']
- ping_future.result()
- target_atten = 0
- logging.debug('RSSI @ {0:.2f}dB attenuation = {1:.2f}'.format(
- target_atten, current_rssi))
- within_range = 0
- for idx in range(20):
- atten_delta = max(min(current_rssi - target_rssi, 20), -20)
- target_atten = int((target_atten + atten_delta) * 4) / 4
- if target_atten < 0:
- return 0
- if target_atten > attenuators[0].get_max_atten():
- return attenuators[0].get_max_atten()
- for atten in attenuators:
- atten.set_atten(target_atten, strict=False, retry=True)
- ping_future = get_ping_stats_nb(src_device=ping_server,
- dest_address=dut_ip,
- ping_duration=1.5,
- ping_interval=0.02,
- ping_size=64)
- current_rssi = get_connected_rssi(dut,
- num_measurements=4,
- polling_frequency=0.25,
- first_measurement_delay=0.5,
- disconnect_warning=1,
- ignore_samples=1)
- current_rssi = current_rssi['signal_poll_rssi']['mean']
- ping_future.result()
- logging.info('RSSI @ {0:.2f}dB attenuation = {1:.2f}'.format(
- target_atten, current_rssi))
- if abs(current_rssi - target_rssi) < 1:
- if within_range:
- logging.info(
- 'Reached RSSI: {0:.2f}. Target RSSI: {1:.2f}.'
- 'Attenuation: {2:.2f}, Iterations = {3:.2f}'.format(
- current_rssi, target_rssi, target_atten, idx))
- return target_atten
- else:
- within_range = True
- else:
- within_range = False
- return target_atten
-
-
-def get_current_atten_dut_chain_map(attenuators,
- dut,
- ping_server,
- ping_from_dut=False):
- """Function to detect mapping between attenuator ports and DUT chains.
-
- This function detects the mapping between attenuator ports and DUT chains
- in cases where DUT chains are connected to only one attenuator port. The
- function assumes the DUT is already connected to a wifi network. The
- function starts by measuring per chain RSSI at 0 attenuation, then
- attenuates one port at a time looking for the chain that reports a lower
- RSSI.
-
- Args:
- attenuators: list of attenuator ports
- dut: android device object assumed connected to a wifi network.
- ping_server: ssh connection object to ping server
- ping_from_dut: boolean controlling whether to ping from or to dut
- Returns:
- chain_map: list of dut chains, one entry per attenuator port
- """
- # Set attenuator to 0 dB
- for atten in attenuators:
- atten.set_atten(0, strict=False, retry=True)
- # Start ping traffic
- dut_ip = dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
- if ping_from_dut:
- ping_future = get_ping_stats_nb(dut, ping_server._settings.hostname,
- 11, 0.02, 64)
- else:
- ping_future = get_ping_stats_nb(ping_server, dut_ip, 11, 0.02, 64)
- # Measure starting RSSI
- base_rssi = get_connected_rssi(dut, 4, 0.25, 1)
- chain0_base_rssi = base_rssi['chain_0_rssi']['mean']
- chain1_base_rssi = base_rssi['chain_1_rssi']['mean']
- if chain0_base_rssi < -70 or chain1_base_rssi < -70:
- logging.warning('RSSI might be too low to get reliable chain map.')
- # Compile chain map by attenuating one path at a time and seeing which
- # chain's RSSI degrades
- chain_map = []
- for test_atten in attenuators:
- # Set one attenuator to 30 dB down
- test_atten.set_atten(30, strict=False, retry=True)
- # Get new RSSI
- test_rssi = get_connected_rssi(dut, 4, 0.25, 1)
- # Assign attenuator to path that has lower RSSI
- if chain0_base_rssi > -70 and chain0_base_rssi - test_rssi[
- 'chain_0_rssi']['mean'] > 10:
- chain_map.append('DUT-Chain-0')
- elif chain1_base_rssi > -70 and chain1_base_rssi - test_rssi[
- 'chain_1_rssi']['mean'] > 10:
- chain_map.append('DUT-Chain-1')
- else:
- chain_map.append(None)
- # Reset attenuator to 0
- test_atten.set_atten(0, strict=False, retry=True)
- ping_future.result()
- logging.debug('Chain Map: {}'.format(chain_map))
- return chain_map
-
-
-def get_full_rf_connection_map(attenuators,
- dut,
- ping_server,
- networks,
- ping_from_dut=False):
- """Function to detect per-network connections between attenuator and DUT.
-
- This function detects the mapping between attenuator ports and DUT chains
- on all networks in its arguments. The function connects the DUT to each
- network then calls get_current_atten_dut_chain_map to get the connection
- map on the current network. The function outputs the results in two formats
- to enable easy access when users are interested in indexing by network or
- attenuator port.
-
- Args:
- attenuators: list of attenuator ports
- dut: android device object assumed connected to a wifi network.
- ping_server: ssh connection object to ping server
- networks: dict of network IDs and configs
- Returns:
- rf_map_by_network: dict of RF connections indexed by network.
- rf_map_by_atten: list of RF connections indexed by attenuator
- """
- for atten in attenuators:
- atten.set_atten(0, strict=False, retry=True)
-
- rf_map_by_network = collections.OrderedDict()
- rf_map_by_atten = [[] for atten in attenuators]
- for net_id, net_config in networks.items():
- wutils.reset_wifi(dut)
- wutils.wifi_connect(dut,
- net_config,
- num_of_tries=1,
- assert_on_fail=False,
- check_connectivity=False)
- rf_map_by_network[net_id] = get_current_atten_dut_chain_map(
- attenuators, dut, ping_server, ping_from_dut)
- for idx, chain in enumerate(rf_map_by_network[net_id]):
- if chain:
- rf_map_by_atten[idx].append({
- 'network': net_id,
- 'dut_chain': chain
- })
- logging.debug('RF Map (by Network): {}'.format(rf_map_by_network))
- logging.debug('RF Map (by Atten): {}'.format(rf_map_by_atten))
-
- return rf_map_by_network, rf_map_by_atten
-
-
-# Generic device utils
-def get_dut_temperature(dut):
- """Function to get dut temperature.
-
- The function fetches and returns the reading from the temperature sensor
- used for skin temperature and thermal throttling.
-
- Args:
- dut: AndroidDevice of interest
- Returns:
- temperature: device temperature. 0 if temperature could not be read
- """
- candidate_zones = [
- '/sys/devices/virtual/thermal/tz-by-name/skin-therm/temp',
- '/sys/devices/virtual/thermal/tz-by-name/sdm-therm-monitor/temp',
- '/sys/devices/virtual/thermal/tz-by-name/sdm-therm-adc/temp',
- '/sys/devices/virtual/thermal/tz-by-name/back_therm/temp',
- '/dev/thermal/tz-by-name/quiet_therm/temp'
- ]
- for zone in candidate_zones:
- try:
- temperature = int(dut.adb.shell('cat {}'.format(zone)))
- break
- except:
- temperature = 0
- if temperature == 0:
- logging.debug('Could not check DUT temperature.')
- elif temperature > 100:
- temperature = temperature / 1000
- return temperature
-
-
-def wait_for_dut_cooldown(dut, target_temp=50, timeout=300):
- """Function to wait for a DUT to cool down.
-
- Args:
- dut: AndroidDevice of interest
- target_temp: target cooldown temperature
- timeout: maxt time to wait for cooldown
- """
- start_time = time.time()
- while time.time() - start_time < timeout:
- temperature = get_dut_temperature(dut)
- if temperature < target_temp:
- break
- time.sleep(SHORT_SLEEP)
- elapsed_time = time.time() - start_time
- logging.debug('DUT Final Temperature: {}C. Cooldown duration: {}'.format(
- temperature, elapsed_time))
-
-
-def health_check(dut, batt_thresh=5, temp_threshold=53, cooldown=1):
- """Function to check health status of a DUT.
-
- The function checks both battery levels and temperature to avoid DUT
- powering off during the test.
-
- Args:
- dut: AndroidDevice of interest
- batt_thresh: battery level threshold
- temp_threshold: temperature threshold
- cooldown: flag to wait for DUT to cool down when overheating
- Returns:
- health_check: boolean confirming device is healthy
- """
- health_check = True
- battery_level = utils.get_battery_level(dut)
- if battery_level < batt_thresh:
- logging.warning('Battery level low ({}%)'.format(battery_level))
- health_check = False
- else:
- logging.debug('Battery level = {}%'.format(battery_level))
-
- temperature = get_dut_temperature(dut)
- if temperature > temp_threshold:
- if cooldown:
- logging.warning(
- 'Waiting for DUT to cooldown. ({} C)'.format(temperature))
- wait_for_dut_cooldown(dut, target_temp=temp_threshold - 5)
- else:
- logging.warning('DUT Overheating ({} C)'.format(temperature))
- health_check = False
- else:
- logging.debug('DUT Temperature = {} C'.format(temperature))
- return health_check
-
-
-# Wifi Device utils
-def detect_wifi_platform(dut):
- ini_check = len(dut.get_file_names('/vendor/firmware/wlan/qca_cld/'))
- if ini_check:
- wifi_platform = 'qcom'
- else:
- wifi_platform = 'brcm'
- return wifi_platform
-
-
-def detect_wifi_decorator(f):
- def wrap(*args, **kwargs):
- if 'dut' in kwargs:
- dut = kwargs['dut']
- else:
- dut = next(arg for arg in args if type(arg) == AndroidDevice)
- f_decorated = '{}_{}'.format(f.__name__, detect_wifi_platform(dut))
- f_decorated = globals()[f_decorated]
- return (f_decorated(*args, **kwargs))
-
- return wrap
-
-
-# Rssi Utilities
-def empty_rssi_result():
- return collections.OrderedDict([('data', []), ('mean', None),
- ('stdev', None)])
-
-
-@detect_wifi_decorator
-def get_connected_rssi(dut,
- num_measurements=1,
- polling_frequency=SHORT_SLEEP,
- first_measurement_delay=0,
- disconnect_warning=True,
- ignore_samples=0,
- interface=None):
- """Gets all RSSI values reported for the connected access point/BSSID.
-
- Args:
- dut: android device object from which to get RSSI
- num_measurements: number of scans done, and RSSIs collected
- polling_frequency: time to wait between RSSI measurements
- disconnect_warning: boolean controlling disconnection logging messages
- ignore_samples: number of leading samples to ignore
- Returns:
- connected_rssi: dict containing the measurements results for
- all reported RSSI values (signal_poll, per chain, etc.) and their
- statistics
- """
- pass
-
-
-@nonblocking
-def get_connected_rssi_nb(dut,
- num_measurements=1,
- polling_frequency=SHORT_SLEEP,
- first_measurement_delay=0,
- disconnect_warning=True,
- ignore_samples=0,
- interface=None):
- return get_connected_rssi(dut, num_measurements, polling_frequency,
- first_measurement_delay, disconnect_warning,
- ignore_samples, interface)
-
-
-def get_connected_rssi_qcom(dut,
- num_measurements=1,
- polling_frequency=SHORT_SLEEP,
- first_measurement_delay=0,
- disconnect_warning=True,
- ignore_samples=0,
- interface=None):
- # yapf: disable
- connected_rssi = collections.OrderedDict(
- [('time_stamp', []),
- ('bssid', []), ('ssid', []), ('frequency', []),
- ('signal_poll_rssi', empty_rssi_result()),
- ('signal_poll_avg_rssi', empty_rssi_result()),
- ('chain_0_rssi', empty_rssi_result()),
- ('chain_1_rssi', empty_rssi_result())])
- # yapf: enable
- previous_bssid = 'disconnected'
- t0 = time.time()
- time.sleep(first_measurement_delay)
- for idx in range(num_measurements):
- measurement_start_time = time.time()
- connected_rssi['time_stamp'].append(measurement_start_time - t0)
- # Get signal poll RSSI
- try:
- if interface is None:
- status_output = dut.adb.shell(WPA_CLI_STATUS)
- else:
- status_output = dut.adb.shell(
- 'wpa_cli -i {} status'.format(interface))
- except:
- status_output = ''
- match = re.search('bssid=.*', status_output)
- if match:
- current_bssid = match.group(0).split('=')[1]
- connected_rssi['bssid'].append(current_bssid)
- else:
- current_bssid = 'disconnected'
- connected_rssi['bssid'].append(current_bssid)
- if disconnect_warning and previous_bssid != 'disconnected':
- logging.warning('WIFI DISCONNECT DETECTED!')
- previous_bssid = current_bssid
- match = re.search('\s+ssid=.*', status_output)
- if match:
- ssid = match.group(0).split('=')[1]
- connected_rssi['ssid'].append(ssid)
- else:
- connected_rssi['ssid'].append('disconnected')
- try:
- if interface is None:
- signal_poll_output = dut.adb.shell(SIGNAL_POLL)
- else:
- signal_poll_output = dut.adb.shell(
- 'wpa_cli -i {} signal_poll'.format(interface))
- except:
- signal_poll_output = ''
- match = re.search('FREQUENCY=.*', signal_poll_output)
- if match:
- frequency = int(match.group(0).split('=')[1])
- connected_rssi['frequency'].append(frequency)
- else:
- connected_rssi['frequency'].append(RSSI_ERROR_VAL)
- match = re.search('RSSI=.*', signal_poll_output)
- if match:
- temp_rssi = int(match.group(0).split('=')[1])
- if temp_rssi == -9999 or temp_rssi == 0:
- connected_rssi['signal_poll_rssi']['data'].append(
- RSSI_ERROR_VAL)
- else:
- connected_rssi['signal_poll_rssi']['data'].append(temp_rssi)
- else:
- connected_rssi['signal_poll_rssi']['data'].append(RSSI_ERROR_VAL)
- match = re.search('AVG_RSSI=.*', signal_poll_output)
- if match:
- connected_rssi['signal_poll_avg_rssi']['data'].append(
- int(match.group(0).split('=')[1]))
- else:
- connected_rssi['signal_poll_avg_rssi']['data'].append(
- RSSI_ERROR_VAL)
-
- # Get per chain RSSI
- try:
- if interface is None:
- per_chain_rssi = dut.adb.shell(STATION_DUMP)
- else:
- per_chain_rssi = ''
- except:
- per_chain_rssi = ''
- match = re.search('.*signal avg:.*', per_chain_rssi)
- if match:
- per_chain_rssi = per_chain_rssi[per_chain_rssi.find('[') +
- 1:per_chain_rssi.find(']')]
- per_chain_rssi = per_chain_rssi.split(', ')
- connected_rssi['chain_0_rssi']['data'].append(
- int(per_chain_rssi[0]))
- connected_rssi['chain_1_rssi']['data'].append(
- int(per_chain_rssi[1]))
- else:
- connected_rssi['chain_0_rssi']['data'].append(RSSI_ERROR_VAL)
- connected_rssi['chain_1_rssi']['data'].append(RSSI_ERROR_VAL)
- measurement_elapsed_time = time.time() - measurement_start_time
- time.sleep(max(0, polling_frequency - measurement_elapsed_time))
-
- # Compute mean RSSIs. Only average valid readings.
- # Output RSSI_ERROR_VAL if no valid connected readings found.
- for key, val in connected_rssi.copy().items():
- if 'data' not in val:
- continue
- filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
- if len(filtered_rssi_values) > ignore_samples:
- filtered_rssi_values = filtered_rssi_values[ignore_samples:]
- if filtered_rssi_values:
- connected_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
- if len(filtered_rssi_values) > 1:
- connected_rssi[key]['stdev'] = statistics.stdev(
- filtered_rssi_values)
- else:
- connected_rssi[key]['stdev'] = 0
- else:
- connected_rssi[key]['mean'] = RSSI_ERROR_VAL
- connected_rssi[key]['stdev'] = RSSI_ERROR_VAL
- return connected_rssi
-
-
-def get_connected_rssi_brcm(dut,
- num_measurements=1,
- polling_frequency=SHORT_SLEEP,
- first_measurement_delay=0,
- disconnect_warning=True,
- ignore_samples=0,
- interface=None):
- # yapf: disable
- connected_rssi = collections.OrderedDict(
- [('time_stamp', []),
- ('bssid', []), ('ssid', []), ('frequency', []),
- ('signal_poll_rssi', empty_rssi_result()),
- ('signal_poll_avg_rssi', empty_rssi_result()),
- ('chain_0_rssi', empty_rssi_result()),
- ('chain_1_rssi', empty_rssi_result())])
-
- # yapf: enable
- previous_bssid = 'disconnected'
- t0 = time.time()
- time.sleep(first_measurement_delay)
- for idx in range(num_measurements):
- measurement_start_time = time.time()
- connected_rssi['time_stamp'].append(measurement_start_time - t0)
- # Get signal poll RSSI
- status_output = dut.adb.shell('wl assoc')
- match = re.search('BSSID:.*', status_output)
-
- if match:
- current_bssid = match.group(0).split('\t')[0]
- current_bssid = current_bssid.split(' ')[1]
- connected_rssi['bssid'].append(current_bssid)
-
- else:
- current_bssid = 'disconnected'
- connected_rssi['bssid'].append(current_bssid)
- if disconnect_warning and previous_bssid != 'disconnected':
- logging.warning('WIFI DISCONNECT DETECTED!')
-
- previous_bssid = current_bssid
- match = re.search('SSID:.*', status_output)
- if match:
- ssid = match.group(0).split(': ')[1]
- connected_rssi['ssid'].append(ssid)
- else:
- connected_rssi['ssid'].append('disconnected')
-
- #TODO: SEARCH MAP ; PICK CENTER CHANNEL
- match = re.search('Primary channel:.*', status_output)
- if match:
- frequency = int(match.group(0).split(':')[1])
- connected_rssi['frequency'].append(frequency)
- else:
- connected_rssi['frequency'].append(RSSI_ERROR_VAL)
-
- try:
- per_chain_rssi = dut.adb.shell('wl phy_rssi_ant')
- except:
- per_chain_rssi = DISCONNECTION_MESSAGE_BRCM
- if DISCONNECTION_MESSAGE_BRCM not in per_chain_rssi:
- per_chain_rssi = per_chain_rssi.split(' ')
- chain_0_rssi = int(per_chain_rssi[1])
- chain_1_rssi = int(per_chain_rssi[4])
- connected_rssi['chain_0_rssi']['data'].append(chain_0_rssi)
- connected_rssi['chain_1_rssi']['data'].append(chain_1_rssi)
- combined_rssi = math.pow(10, chain_0_rssi / 10) + math.pow(
- 10, chain_1_rssi / 10)
- combined_rssi = 10 * math.log10(combined_rssi)
- connected_rssi['signal_poll_rssi']['data'].append(combined_rssi)
- connected_rssi['signal_poll_avg_rssi']['data'].append(
- combined_rssi)
- else:
- connected_rssi['chain_0_rssi']['data'].append(RSSI_ERROR_VAL)
- connected_rssi['chain_1_rssi']['data'].append(RSSI_ERROR_VAL)
- connected_rssi['signal_poll_rssi']['data'].append(RSSI_ERROR_VAL)
- connected_rssi['signal_poll_avg_rssi']['data'].append(
- RSSI_ERROR_VAL)
- measurement_elapsed_time = time.time() - measurement_start_time
- time.sleep(max(0, polling_frequency - measurement_elapsed_time))
-
- # Statistics, Statistics
- for key, val in connected_rssi.copy().items():
- if 'data' not in val:
- continue
- filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
- if len(filtered_rssi_values) > ignore_samples:
- filtered_rssi_values = filtered_rssi_values[ignore_samples:]
- if filtered_rssi_values:
- connected_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
- if len(filtered_rssi_values) > 1:
- connected_rssi[key]['stdev'] = statistics.stdev(
- filtered_rssi_values)
- else:
- connected_rssi[key]['stdev'] = 0
- else:
- connected_rssi[key]['mean'] = RSSI_ERROR_VAL
- connected_rssi[key]['stdev'] = RSSI_ERROR_VAL
-
- return connected_rssi
-
-
-@detect_wifi_decorator
-def get_scan_rssi(dut, tracked_bssids, num_measurements=1):
- """Gets scan RSSI for specified BSSIDs.
-
- Args:
- dut: android device object from which to get RSSI
- tracked_bssids: array of BSSIDs to gather RSSI data for
- num_measurements: number of scans done, and RSSIs collected
- Returns:
- scan_rssi: dict containing the measurement results as well as the
- statistics of the scan RSSI for all BSSIDs in tracked_bssids
- """
- pass
-
-
-@nonblocking
-def get_scan_rssi_nb(dut, tracked_bssids, num_measurements=1):
- return get_scan_rssi(dut, tracked_bssids, num_measurements)
-
-
-def get_scan_rssi_qcom(dut, tracked_bssids, num_measurements=1):
- scan_rssi = collections.OrderedDict()
- for bssid in tracked_bssids:
- scan_rssi[bssid] = empty_rssi_result()
- for idx in range(num_measurements):
- scan_output = dut.adb.shell(SCAN)
- time.sleep(MED_SLEEP)
- scan_output = dut.adb.shell(SCAN_RESULTS)
- for bssid in tracked_bssids:
- bssid_result = re.search(bssid + '.*',
- scan_output,
- flags=re.IGNORECASE)
- if bssid_result:
- bssid_result = bssid_result.group(0).split('\t')
- scan_rssi[bssid]['data'].append(int(bssid_result[2]))
- else:
- scan_rssi[bssid]['data'].append(RSSI_ERROR_VAL)
- # Compute mean RSSIs. Only average valid readings.
- # Output RSSI_ERROR_VAL if no readings found.
- for key, val in scan_rssi.items():
- filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
- if filtered_rssi_values:
- scan_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
- if len(filtered_rssi_values) > 1:
- scan_rssi[key]['stdev'] = statistics.stdev(
- filtered_rssi_values)
- else:
- scan_rssi[key]['stdev'] = 0
- else:
- scan_rssi[key]['mean'] = RSSI_ERROR_VAL
- scan_rssi[key]['stdev'] = RSSI_ERROR_VAL
- return scan_rssi
-
-
-def get_scan_rssi_brcm(dut, tracked_bssids, num_measurements=1):
- scan_rssi = collections.OrderedDict()
- for bssid in tracked_bssids:
- scan_rssi[bssid] = empty_rssi_result()
- for idx in range(num_measurements):
- scan_output = dut.adb.shell('cmd wifi start-scan')
- time.sleep(MED_SLEEP)
- scan_output = dut.adb.shell('cmd wifi list-scan-results')
- for bssid in tracked_bssids:
- bssid_result = re.search(bssid + '.*',
- scan_output,
- flags=re.IGNORECASE)
- if bssid_result:
- bssid_result = bssid_result.group(0).split()
- print(bssid_result)
- scan_rssi[bssid]['data'].append(int(bssid_result[2]))
- else:
- scan_rssi[bssid]['data'].append(RSSI_ERROR_VAL)
- # Compute mean RSSIs. Only average valid readings.
- # Output RSSI_ERROR_VAL if no readings found.
- for key, val in scan_rssi.items():
- filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
- if filtered_rssi_values:
- scan_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
- if len(filtered_rssi_values) > 1:
- scan_rssi[key]['stdev'] = statistics.stdev(
- filtered_rssi_values)
- else:
- scan_rssi[key]['stdev'] = 0
- else:
- scan_rssi[key]['mean'] = RSSI_ERROR_VAL
- scan_rssi[key]['stdev'] = RSSI_ERROR_VAL
- return scan_rssi
-
-
-@detect_wifi_decorator
-def get_sw_signature(dut):
- """Function that checks the signature for wifi firmware and config files.
-
- Returns:
- bdf_signature: signature consisting of last three digits of bdf cksums
- fw_signature: floating point firmware version, i.e., major.minor
- """
- pass
-
-
-def get_sw_signature_qcom(dut):
- bdf_output = dut.adb.shell('cksum /vendor/firmware/bdwlan*')
- logging.debug('BDF Checksum output: {}'.format(bdf_output))
- bdf_signature = sum(
- [int(line.split(' ')[0]) for line in bdf_output.splitlines()]) % 1000
-
- fw_output = dut.adb.shell('halutil -logger -get fw')
- logging.debug('Firmware version output: {}'.format(fw_output))
- fw_version = re.search(FW_REGEX, fw_output).group('firmware')
- fw_signature = fw_version.split('.')[-3:-1]
- fw_signature = float('.'.join(fw_signature))
- serial_hash = int(hashlib.md5(dut.serial.encode()).hexdigest(), 16) % 1000
- return {
- 'config_signature': bdf_signature,
- 'fw_signature': fw_signature,
- 'serial_hash': serial_hash
- }
-
-
-def get_sw_signature_brcm(dut):
- bdf_output = dut.adb.shell('cksum /vendor/etc/wifi/bcmdhd*')
- logging.debug('BDF Checksum output: {}'.format(bdf_output))
- bdf_signature = sum(
- [int(line.split(' ')[0]) for line in bdf_output.splitlines()]) % 1000
-
- fw_output = dut.adb.shell('getprop vendor.wlan.firmware.version')
- logging.debug('Firmware version output: {}'.format(fw_output))
- fw_version = fw_output.split('.')[-1]
- driver_output = dut.adb.shell('getprop vendor.wlan.driver.version')
- driver_version = driver_output.split('.')[-1]
- fw_signature = float('{}.{}'.format(fw_version, driver_version))
- serial_hash = int(hashlib.md5(dut.serial.encode()).hexdigest(), 16) % 1000
- return {
- 'config_signature': bdf_signature,
- 'fw_signature': fw_signature,
- 'serial_hash': serial_hash
- }
-
-
-@detect_wifi_decorator
-def push_config(dut, config_file):
- """Function to push Wifi BDF files
-
- This function checks for existing wifi bdf files and over writes them all,
- for simplicity, with the bdf file provided in the arguments. The dut is
- rebooted for the bdf file to take effect
-
- Args:
- dut: dut to push bdf file to
- config_file: path to bdf_file to push
- """
- pass
-
-
-def push_config_qcom(dut, config_file):
- config_files_list = dut.adb.shell(
- 'ls /vendor/firmware/bdwlan*').splitlines()
- for dst_file in config_files_list:
- dut.push_system_file(config_file, dst_file)
- dut.reboot()
-
-
-def push_config_brcm(dut, config_file):
- config_files_list = dut.adb.shell('ls /vendor/etc/*.cal').splitlines()
- for dst_file in config_files_list:
- dut.push_system_file(config_file, dst_file)
- dut.reboot()
-
-
-def push_firmware(dut, firmware_files):
- """Function to push Wifi firmware files
-
- Args:
- dut: dut to push bdf file to
- firmware_files: path to wlanmdsp.mbn file
- datamsc_file: path to Data.msc file
- """
- for file in firmware_files:
- dut.push_system_file(file, '/vendor/firmware/')
- dut.reboot()
-
-
-@detect_wifi_decorator
-def start_wifi_logging(dut):
- """Function to start collecting wifi-related logs"""
- pass
-
-
-def start_wifi_logging_qcom(dut):
- dut.droid.wifiEnableVerboseLogging(1)
- msg = "Failed to enable WiFi verbose logging."
- asserts.assert_equal(dut.droid.wifiGetVerboseLoggingLevel(), 1, msg)
- logging.info('Starting CNSS logs')
- dut.adb.shell("find /data/vendor/wifi/wlan_logs/ -type f -delete",
- ignore_status=True)
- dut.adb.shell_nb('cnss_diag -f -s')
-
-
-def start_wifi_logging_brcm(dut):
- pass
-
-
-@detect_wifi_decorator
-def stop_wifi_logging(dut):
- """Function to start collecting wifi-related logs"""
- pass
-
-
-def stop_wifi_logging_qcom(dut):
- logging.info('Stopping CNSS logs')
- dut.adb.shell('killall cnss_diag')
- logs = dut.get_file_names("/data/vendor/wifi/wlan_logs/")
- if logs:
- dut.log.info("Pulling cnss_diag logs %s", logs)
- log_path = os.path.join(dut.device_log_path,
- "CNSS_DIAG_%s" % dut.serial)
- os.makedirs(log_path, exist_ok=True)
- dut.pull_files(logs, log_path)
-
-
-def stop_wifi_logging_brcm(dut):
- pass
-
-
-def _set_ini_fields(ini_file_path, ini_field_dict):
- template_regex = r'^{}=[0-9,.x-]+'
- with open(ini_file_path, 'r') as f:
- ini_lines = f.read().splitlines()
- for idx, line in enumerate(ini_lines):
- for field_name, field_value in ini_field_dict.items():
- line_regex = re.compile(template_regex.format(field_name))
- if re.match(line_regex, line):
- ini_lines[idx] = '{}={}'.format(field_name, field_value)
- print(ini_lines[idx])
- with open(ini_file_path, 'w') as f:
- f.write('\n'.join(ini_lines) + '\n')
-
-
-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.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()
-
-
-def set_ini_single_chain_mode(dut, chain):
- ini_fields = {
- 'gEnable2x2': 0,
- 'gSetTxChainmask1x1': chain + 1,
- 'gSetRxChainmask1x1': chain + 1,
- 'gDualMacFeatureDisable': 1,
- 'gDot11Mode': 0
- }
- _edit_dut_ini(dut, ini_fields)
-
-
-def set_ini_two_chain_mode(dut):
- ini_fields = {
- 'gEnable2x2': 2,
- 'gSetTxChainmask1x1': 1,
- 'gSetRxChainmask1x1': 1,
- 'gDualMacFeatureDisable': 6,
- 'gDot11Mode': 0
- }
- _edit_dut_ini(dut, ini_fields)
-
-
-def set_ini_tx_mode(dut, mode):
- TX_MODE_DICT = {
- 'Auto': 0,
- '11n': 4,
- '11ac': 9,
- '11abg': 1,
- '11b': 2,
- '11': 3,
- '11g only': 5,
- '11n only': 6,
- '11b only': 7,
- '11ac only': 8
- }
-
- ini_fields = {
- 'gEnable2x2': 2,
- 'gSetTxChainmask1x1': 1,
- 'gSetRxChainmask1x1': 1,
- 'gDualMacFeatureDisable': 6,
- 'gDot11Mode': TX_MODE_DICT[mode]
- }
- _edit_dut_ini(dut, ini_fields)
-
-
-# Link layer stats utilities
-class LinkLayerStats():
- def __new__(self, dut, llstats_enabled=True):
- if detect_wifi_platform(dut) == 'qcom':
- return LinkLayerStatsQcom(dut, llstats_enabled=True)
- else:
- return LinkLayerStatsBrcm(dut, llstats_enabled=True)
-
-
-class LinkLayerStatsQcom():
-
- LLSTATS_CMD = 'cat /d/wlan0/ll_stats'
- PEER_REGEX = 'LL_STATS_PEER_ALL'
- MCS_REGEX = re.compile(
- r'preamble: (?P<mode>\S+), nss: (?P<num_streams>\S+), bw: (?P<bw>\S+), '
- 'mcs: (?P<mcs>\S+), bitrate: (?P<rate>\S+), txmpdu: (?P<txmpdu>\S+), '
- 'rxmpdu: (?P<rxmpdu>\S+), mpdu_lost: (?P<mpdu_lost>\S+), '
- 'retries: (?P<retries>\S+), retries_short: (?P<retries_short>\S+), '
- '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}
-
- def __init__(self, dut, llstats_enabled=True):
- self.dut = dut
- self.llstats_enabled = llstats_enabled
- self.llstats_cumulative = self._empty_llstats()
- self.llstats_incremental = self._empty_llstats()
-
- def update_stats(self):
- if self.llstats_enabled:
- try:
- llstats_output = self.dut.adb.shell(self.LLSTATS_CMD,
- timeout=0.1)
- except:
- llstats_output = ''
- else:
- llstats_output = ''
- self._update_stats(llstats_output)
-
- def reset_stats(self):
- self.llstats_cumulative = self._empty_llstats()
- self.llstats_incremental = self._empty_llstats()
-
- def _empty_llstats(self):
- return collections.OrderedDict(mcs_stats=collections.OrderedDict(),
- summary=collections.OrderedDict())
-
- def _empty_mcs_stat(self):
- return collections.OrderedDict(txmpdu=0,
- rxmpdu=0,
- mpdu_lost=0,
- retries=0,
- retries_short=0,
- retries_long=0)
-
- def _mcs_id_to_string(self, mcs_id):
- mcs_string = '{} {}MHz Nss{} MCS{} {}Mbps'.format(
- mcs_id.mode, mcs_id.bandwidth, mcs_id.num_streams, mcs_id.mcs,
- mcs_id.rate)
- return mcs_string
-
- def _parse_mcs_stats(self, llstats_output):
- llstats_dict = {}
- # Look for per-peer stats
- match = re.search(self.PEER_REGEX, llstats_output)
- if not match:
- self.reset_stats()
- return collections.OrderedDict()
- # Find and process all matches for per stream stats
- match_iter = re.finditer(self.MCS_REGEX, llstats_output)
- for match in match_iter:
- 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('rate'), 16) / 1000)
- current_stats = collections.OrderedDict(
- txmpdu=int(match.group('txmpdu')),
- rxmpdu=int(match.group('rxmpdu')),
- mpdu_lost=int(match.group('mpdu_lost')),
- retries=int(match.group('retries')),
- retries_short=int(match.group('retries_short')),
- retries_long=int(match.group('retries_long')))
- llstats_dict[self._mcs_id_to_string(current_mcs)] = current_stats
- return llstats_dict
-
- def _diff_mcs_stats(self, new_stats, old_stats):
- stats_diff = collections.OrderedDict()
- for stat_key in new_stats.keys():
- stats_diff[stat_key] = new_stats[stat_key] - old_stats[stat_key]
- return stats_diff
-
- def _generate_stats_summary(self, llstats_dict):
- llstats_summary = collections.OrderedDict(common_tx_mcs=None,
- common_tx_mcs_count=0,
- common_tx_mcs_freq=0,
- common_rx_mcs=None,
- common_rx_mcs_count=0,
- common_rx_mcs_freq=0)
- txmpdu_count = 0
- rxmpdu_count = 0
- for mcs_id, mcs_stats in llstats_dict['mcs_stats'].items():
- 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']
- if mcs_stats['rxmpdu'] > llstats_summary['common_rx_mcs_count']:
- llstats_summary['common_rx_mcs'] = mcs_id
- llstats_summary['common_rx_mcs_count'] = mcs_stats['rxmpdu']
- txmpdu_count += mcs_stats['txmpdu']
- rxmpdu_count += mcs_stats['rxmpdu']
- if txmpdu_count:
- llstats_summary['common_tx_mcs_freq'] = (
- llstats_summary['common_tx_mcs_count'] / txmpdu_count)
- if rxmpdu_count:
- llstats_summary['common_rx_mcs_freq'] = (
- llstats_summary['common_rx_mcs_count'] / rxmpdu_count)
- return llstats_summary
-
- def _update_stats(self, llstats_output):
- # Parse stats
- new_llstats = self._empty_llstats()
- new_llstats['mcs_stats'] = self._parse_mcs_stats(llstats_output)
- # Save old stats and set new cumulative stats
- old_llstats = self.llstats_cumulative.copy()
- self.llstats_cumulative = new_llstats.copy()
- # Compute difference between new and old stats
- self.llstats_incremental = self._empty_llstats()
- for mcs_id, new_mcs_stats in new_llstats['mcs_stats'].items():
- old_mcs_stats = old_llstats['mcs_stats'].get(
- mcs_id, self._empty_mcs_stat())
- self.llstats_incremental['mcs_stats'][
- mcs_id] = self._diff_mcs_stats(new_mcs_stats, old_mcs_stats)
- # Generate llstats summary
- self.llstats_incremental['summary'] = self._generate_stats_summary(
- self.llstats_incremental)
- self.llstats_cumulative['summary'] = self._generate_stats_summary(
- self.llstats_cumulative)
-
-
-class LinkLayerStatsBrcm():
- def __init__(self, dut, llstats_enabled=True):
- self.dut = dut
- self.llstats_enabled = llstats_enabled
- self.llstats_incremental = self._empty_llstats()
- self.llstats_cumulative = self.llstats_incremental
-
- def _empty_llstats(self):
- return collections.OrderedDict(mcs_stats=collections.OrderedDict(),
- summary=collections.OrderedDict())
-
- def update_stats(self):
- self.llstats_incremental = self._empty_llstats()
- self.llstats_incremental['summary'] = collections.OrderedDict(
- common_tx_mcs=None,
- common_tx_mcs_count=1,
- common_tx_mcs_freq=1,
- common_rx_mcs=None,
- common_rx_mcs_count=1,
- common_rx_mcs_freq=1)
- if self.llstats_enabled:
- try:
- rate_info = self.dut.adb.shell('wl rate_info', timeout=0.1)
- self.llstats_incremental['summary'][
- 'common_tx_mcs'] = '{} Mbps'.format(
- re.findall('\[Tx\]:'
- ' (\d+[.]*\d* Mbps)', rate_info))
- self.llstats_incremental['summary'][
- 'common_rx_mcs'] = '{} Mbps'.format(
- re.findall('\[Rx\]:'
- ' (\d+[.]*\d* Mbps)', rate_info))
- except:
- pass
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
new file mode 100644
index 0000000..4e32f1a
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/__init__.py
@@ -0,0 +1,747 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 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 collections
+import importlib
+import ipaddress
+import logging
+import numpy
+import re
+import time
+from acts import asserts
+from acts import utils
+from acts.controllers.android_device import AndroidDevice
+from acts.controllers.utils_lib import ssh
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils import ping_utils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils import qcom_utils
+from acts_contrib.test_utils.wifi.wifi_performance_test_utils import brcm_utils
+
+from concurrent.futures import ThreadPoolExecutor
+
+SHORT_SLEEP = 1
+MED_SLEEP = 6
+CHANNELS_6GHz = ['6g{}'.format(4 * x + 1) for x in range(59)]
+BAND_TO_CHANNEL_MAP = {
+ '2.4GHz': list(range(1, 14)),
+ 'UNII-1': [36, 40, 44, 48],
+ 'UNII-2':
+ [52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 140],
+ 'UNII-3': [149, 153, 157, 161, 165],
+ '6GHz': CHANNELS_6GHz
+}
+CHANNEL_TO_BAND_MAP = {
+ channel: band
+ for band, channels in BAND_TO_CHANNEL_MAP.items() for channel in channels
+}
+
+
+# Decorators
+def nonblocking(f):
+ """Creates a decorator transforming function calls to non-blocking"""
+ def wrap(*args, **kwargs):
+ executor = ThreadPoolExecutor(max_workers=1)
+ thread_future = executor.submit(f, *args, **kwargs)
+ # Ensure resources are freed up when executor ruturns or raises
+ executor.shutdown(wait=False)
+ return thread_future
+
+ return wrap
+
+
+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/'))
+ if qcom_check:
+ dut.wifi_platform = 'qcom'
+ else:
+ dut.wifi_platform = 'brcm'
+ return dut.wifi_platform
+
+
+def detect_wifi_decorator(f):
+ def wrap(*args, **kwargs):
+ if 'dut' in kwargs:
+ dut = kwargs['dut']
+ else:
+ dut = next(arg for arg in args if type(arg) == AndroidDevice)
+ dut_package = 'acts_contrib.test_utils.wifi.wifi_performance_test_utils.{}_utils'.format(
+ detect_wifi_platform(dut))
+ dut_package = importlib.import_module(dut_package)
+ f_decorated = getattr(dut_package, f.__name__, lambda: None)
+ return (f_decorated(*args, **kwargs))
+
+ return wrap
+
+
+# JSON serializer
+def serialize_dict(input_dict):
+ """Function to serialize dicts to enable JSON output"""
+ output_dict = collections.OrderedDict()
+ for key, value in input_dict.items():
+ output_dict[_serialize_value(key)] = _serialize_value(value)
+ return output_dict
+
+
+def _serialize_value(value):
+ """Function to recursively serialize dict entries to enable JSON output"""
+ if isinstance(value, tuple):
+ return str(value)
+ if isinstance(value, numpy.int64):
+ return int(value)
+ if isinstance(value, numpy.float64):
+ return float(value)
+ if isinstance(value, list):
+ return [_serialize_value(x) for x in value]
+ if isinstance(value, numpy.ndarray):
+ return [_serialize_value(x) for x in value]
+ elif isinstance(value, dict):
+ return serialize_dict(value)
+ elif type(value) in (float, int, bool, str):
+ return value
+ else:
+ return "Non-serializable object"
+
+
+def extract_sub_dict(full_dict, fields):
+ sub_dict = collections.OrderedDict(
+ (field, full_dict[field]) for field in fields)
+ return sub_dict
+
+
+# Miscellaneous Wifi Utilities
+def check_skip_conditions(testcase_params,
+ dut,
+ access_point,
+ ota_chamber=None):
+ """Checks if test should be skipped."""
+ # Check battery level before test
+ if not health_check(dut, 10):
+ asserts.skip('DUT battery level too low.')
+ if not access_point.band_lookup_by_channel(testcase_params['channel']):
+ asserts.skip('AP does not support requested channel.')
+ if ota_chamber and CHANNEL_TO_BAND_MAP[
+ testcase_params['channel']] not in ota_chamber.SUPPORTED_BANDS:
+ asserts.skip('OTA chamber does not support requested channel.')
+ # Check if 6GHz is supported by checking capabilities in the US.
+ if not dut.droid.wifiCheckState():
+ wutils.wifi_toggle_state(dut, True)
+ iw_list = dut.adb.shell('iw list')
+ supports_6ghz = '6135 MHz' in iw_list
+ supports_160mhz = 'Supported Channel Width: 160 MHz' in iw_list
+ if testcase_params.get('bandwidth', 20) == 160 and not supports_160mhz:
+ asserts.skip('DUT does not support 160 MHz networks.')
+ if testcase_params.get('channel',
+ 6) in CHANNELS_6GHz and not supports_6ghz:
+ asserts.skip('DUT does not support 6 GHz band.')
+
+
+def validate_network(dut, ssid):
+ """Check that DUT has a valid internet connection through expected SSID
+
+ Args:
+ dut: android device of interest
+ ssid: expected ssid
+ """
+ try:
+ connected = wutils.validate_connection(dut, wait_time=3) is not None
+ current_network = dut.droid.wifiGetConnectionInfo()
+ except:
+ connected = False
+ current_network = None
+ if connected and current_network['SSID'] == ssid:
+ return True
+ else:
+ return False
+
+
+def get_server_address(ssh_connection, dut_ip, subnet_mask):
+ """Get server address on a specific subnet,
+
+ This function retrieves the LAN or WAN IP of a remote machine used in
+ testing. If subnet_mask is set to 'public' it returns a machines global ip,
+ else it returns the ip belonging to the dut local network given the dut's
+ ip and subnet mask.
+
+ Args:
+ ssh_connection: object representing server for which we want an ip
+ dut_ip: string in ip address format, i.e., xxx.xxx.xxx.xxx
+ subnet_mask: string representing subnet mask (public for global ip)
+ """
+ ifconfig_out = ssh_connection.run('ifconfig').stdout
+ ip_list = re.findall('inet (?:addr:)?(\d+.\d+.\d+.\d+)', ifconfig_out)
+ ip_list = [ipaddress.ip_address(ip) for ip in ip_list]
+
+ if subnet_mask == 'public':
+ for ip in ip_list:
+ # is_global is not used to allow for CGNAT ips in 100.x.y.z range
+ if not ip.is_private:
+ return str(ip)
+ else:
+ dut_network = ipaddress.ip_network('{}/{}'.format(dut_ip, subnet_mask),
+ strict=False)
+ for ip in ip_list:
+ if ip in dut_network:
+ return str(ip)
+ logging.error('No IP address found in requested subnet')
+
+
+# Ping utilities
+def get_ping_stats(src_device, dest_address, ping_duration, ping_interval,
+ ping_size):
+ """Run ping to or from the DUT.
+
+ The function computes either pings the DUT or pings a remote ip from
+ DUT.
+
+ Args:
+ src_device: object representing device to ping from
+ dest_address: ip address to ping
+ ping_duration: timeout to set on the ping process (in seconds)
+ ping_interval: time between pings (in seconds)
+ ping_size: size of ping packet payload
+ Returns:
+ ping_result: dict containing ping results and other meta data
+ """
+ ping_count = int(ping_duration / ping_interval)
+ ping_deadline = int(ping_count * ping_interval) + 1
+ ping_cmd_linux = 'ping -c {} -w {} -i {} -s {} -D'.format(
+ ping_count,
+ ping_deadline,
+ ping_interval,
+ ping_size,
+ )
+
+ ping_cmd_macos = 'ping -c {} -t {} -i {} -s {}'.format(
+ ping_count,
+ ping_deadline,
+ ping_interval,
+ ping_size,
+ )
+
+ if isinstance(src_device, AndroidDevice):
+ ping_cmd = '{} {}'.format(ping_cmd_linux, dest_address)
+ ping_output = src_device.adb.shell(ping_cmd,
+ timeout=ping_deadline + SHORT_SLEEP,
+ ignore_status=True)
+ elif isinstance(src_device, ssh.connection.SshConnection):
+ platform = src_device.run('uname').stdout
+ if 'linux' in platform.lower():
+ ping_cmd = 'sudo {} {}'.format(ping_cmd_linux, dest_address)
+ elif 'darwin' in platform.lower():
+ ping_cmd = "sudo {} {}| while IFS= read -r line; do printf '[%s] %s\n' \"$(gdate '+%s.%N')\" \"$line\"; done".format(
+ ping_cmd_macos, dest_address)
+ ping_output = src_device.run(ping_cmd,
+ timeout=ping_deadline + SHORT_SLEEP,
+ ignore_status=True).stdout
+ else:
+ raise TypeError('Unable to ping using src_device of type %s.' %
+ type(src_device))
+ return ping_utils.PingResult(ping_output.splitlines())
+
+
+@nonblocking
+def get_ping_stats_nb(src_device, dest_address, ping_duration, ping_interval,
+ ping_size):
+ return get_ping_stats(src_device, dest_address, ping_duration,
+ ping_interval, ping_size)
+
+
+# Iperf utilities
+@nonblocking
+def start_iperf_client_nb(iperf_client, iperf_server_address, iperf_args, tag,
+ timeout):
+ return iperf_client.start(iperf_server_address, iperf_args, tag, timeout)
+
+
+def get_iperf_arg_string(duration,
+ reverse_direction,
+ interval=1,
+ traffic_type='TCP',
+ socket_size=None,
+ num_processes=1,
+ udp_throughput='1000M',
+ ipv6=False):
+ """Function to format iperf client arguments.
+
+ This function takes in iperf client parameters and returns a properly
+ formatter iperf arg string to be used in throughput tests.
+
+ Args:
+ duration: iperf duration in seconds
+ reverse_direction: boolean controlling the -R flag for iperf clients
+ interval: iperf print interval
+ traffic_type: string specifying TCP or UDP traffic
+ socket_size: string specifying TCP window or socket buffer, e.g., 2M
+ num_processes: int specifying number of iperf processes
+ udp_throughput: string specifying TX throughput in UDP tests, e.g. 100M
+ ipv6: boolean controlling the use of IP V6
+ Returns:
+ iperf_args: string of formatted iperf args
+ """
+ iperf_args = '-i {} -t {} -J '.format(interval, duration)
+ 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)
+ elif traffic_type.upper() == 'TCP':
+ iperf_args = iperf_args + '-P {} '.format(num_processes)
+ if socket_size:
+ iperf_args = iperf_args + '-w {} '.format(socket_size)
+ if reverse_direction:
+ iperf_args = iperf_args + ' -R'
+ return iperf_args
+
+
+# Attenuator Utilities
+def atten_by_label(atten_list, path_label, atten_level):
+ """Attenuate signals according to their path label.
+
+ Args:
+ atten_list: list of attenuators to iterate over
+ path_label: path label on which to set desired attenuation
+ atten_level: attenuation desired on path
+ """
+ for atten in atten_list:
+ if path_label in atten.path:
+ atten.set_atten(atten_level, retry=True)
+
+
+def get_atten_for_target_rssi(target_rssi, attenuators, dut, ping_server):
+ """Function to estimate attenuation to hit a target RSSI.
+
+ This function estimates a constant attenuation setting on all atennuation
+ ports to hit a target RSSI. The estimate is not meant to be exact or
+ guaranteed.
+
+ Args:
+ target_rssi: rssi of interest
+ attenuators: list of attenuator ports
+ dut: android device object assumed connected to a wifi network.
+ ping_server: ssh connection object to ping server
+ Returns:
+ target_atten: attenuation setting to achieve target_rssi
+ """
+ logging.info('Searching attenuation for RSSI = {}dB'.format(target_rssi))
+ # Set attenuator to 0 dB
+ for atten in attenuators:
+ atten.set_atten(0, strict=False, retry=True)
+ # Start ping traffic
+ dut_ip = dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
+ # Measure starting RSSI
+ ping_future = get_ping_stats_nb(src_device=ping_server,
+ dest_address=dut_ip,
+ ping_duration=1.5,
+ ping_interval=0.02,
+ ping_size=64)
+ current_rssi = get_connected_rssi(dut,
+ num_measurements=4,
+ polling_frequency=0.25,
+ first_measurement_delay=0.5,
+ disconnect_warning=1,
+ ignore_samples=1)
+ current_rssi = current_rssi['signal_poll_rssi']['mean']
+ ping_future.result()
+ target_atten = 0
+ logging.debug('RSSI @ {0:.2f}dB attenuation = {1:.2f}'.format(
+ target_atten, current_rssi))
+ within_range = 0
+ for idx in range(20):
+ atten_delta = max(min(current_rssi - target_rssi, 20), -20)
+ target_atten = int((target_atten + atten_delta) * 4) / 4
+ if target_atten < 0:
+ return 0
+ if target_atten > attenuators[0].get_max_atten():
+ return attenuators[0].get_max_atten()
+ for atten in attenuators:
+ atten.set_atten(target_atten, strict=False, retry=True)
+ ping_future = get_ping_stats_nb(src_device=ping_server,
+ dest_address=dut_ip,
+ ping_duration=1.5,
+ ping_interval=0.02,
+ ping_size=64)
+ current_rssi = get_connected_rssi(dut,
+ num_measurements=4,
+ polling_frequency=0.25,
+ first_measurement_delay=0.5,
+ disconnect_warning=1,
+ ignore_samples=1)
+ current_rssi = current_rssi['signal_poll_rssi']['mean']
+ ping_future.result()
+ logging.info('RSSI @ {0:.2f}dB attenuation = {1:.2f}'.format(
+ target_atten, current_rssi))
+ if abs(current_rssi - target_rssi) < 1:
+ if within_range:
+ logging.info(
+ 'Reached RSSI: {0:.2f}. Target RSSI: {1:.2f}.'
+ 'Attenuation: {2:.2f}, Iterations = {3:.2f}'.format(
+ current_rssi, target_rssi, target_atten, idx))
+ return target_atten
+ else:
+ within_range = True
+ else:
+ within_range = False
+ return target_atten
+
+
+def get_current_atten_dut_chain_map(attenuators,
+ dut,
+ ping_server,
+ ping_from_dut=False):
+ """Function to detect mapping between attenuator ports and DUT chains.
+
+ This function detects the mapping between attenuator ports and DUT chains
+ in cases where DUT chains are connected to only one attenuator port. The
+ function assumes the DUT is already connected to a wifi network. The
+ function starts by measuring per chain RSSI at 0 attenuation, then
+ attenuates one port at a time looking for the chain that reports a lower
+ RSSI.
+
+ Args:
+ attenuators: list of attenuator ports
+ dut: android device object assumed connected to a wifi network.
+ ping_server: ssh connection object to ping server
+ ping_from_dut: boolean controlling whether to ping from or to dut
+ Returns:
+ chain_map: list of dut chains, one entry per attenuator port
+ """
+ # Set attenuator to 0 dB
+ for atten in attenuators:
+ atten.set_atten(0, strict=False, retry=True)
+ # Start ping traffic
+ dut_ip = dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
+ if ping_from_dut:
+ ping_future = get_ping_stats_nb(dut, ping_server._settings.hostname,
+ 11, 0.02, 64)
+ else:
+ ping_future = get_ping_stats_nb(ping_server, dut_ip, 11, 0.02, 64)
+ # Measure starting RSSI
+ base_rssi = get_connected_rssi(dut, 4, 0.25, 1)
+ chain0_base_rssi = base_rssi['chain_0_rssi']['mean']
+ chain1_base_rssi = base_rssi['chain_1_rssi']['mean']
+ if chain0_base_rssi < -70 or chain1_base_rssi < -70:
+ logging.warning('RSSI might be too low to get reliable chain map.')
+ # Compile chain map by attenuating one path at a time and seeing which
+ # chain's RSSI degrades
+ chain_map = []
+ for test_atten in attenuators:
+ # Set one attenuator to 30 dB down
+ test_atten.set_atten(30, strict=False, retry=True)
+ # Get new RSSI
+ test_rssi = get_connected_rssi(dut, 4, 0.25, 1)
+ # Assign attenuator to path that has lower RSSI
+ if chain0_base_rssi > -70 and chain0_base_rssi - test_rssi[
+ 'chain_0_rssi']['mean'] > 10:
+ chain_map.append('DUT-Chain-0')
+ elif chain1_base_rssi > -70 and chain1_base_rssi - test_rssi[
+ 'chain_1_rssi']['mean'] > 10:
+ chain_map.append('DUT-Chain-1')
+ else:
+ chain_map.append(None)
+ # Reset attenuator to 0
+ test_atten.set_atten(0, strict=False, retry=True)
+ ping_future.result()
+ logging.debug('Chain Map: {}'.format(chain_map))
+ return chain_map
+
+
+def get_full_rf_connection_map(attenuators,
+ dut,
+ ping_server,
+ networks,
+ ping_from_dut=False):
+ """Function to detect per-network connections between attenuator and DUT.
+
+ This function detects the mapping between attenuator ports and DUT chains
+ on all networks in its arguments. The function connects the DUT to each
+ network then calls get_current_atten_dut_chain_map to get the connection
+ map on the current network. The function outputs the results in two formats
+ to enable easy access when users are interested in indexing by network or
+ attenuator port.
+
+ Args:
+ attenuators: list of attenuator ports
+ dut: android device object assumed connected to a wifi network.
+ ping_server: ssh connection object to ping server
+ networks: dict of network IDs and configs
+ Returns:
+ rf_map_by_network: dict of RF connections indexed by network.
+ rf_map_by_atten: list of RF connections indexed by attenuator
+ """
+ for atten in attenuators:
+ atten.set_atten(0, strict=False, retry=True)
+
+ rf_map_by_network = collections.OrderedDict()
+ rf_map_by_atten = [[] for atten in attenuators]
+ for net_id, net_config in networks.items():
+ wutils.reset_wifi(dut)
+ wutils.wifi_connect(dut,
+ net_config,
+ num_of_tries=1,
+ assert_on_fail=False,
+ check_connectivity=False)
+ rf_map_by_network[net_id] = get_current_atten_dut_chain_map(
+ attenuators, dut, ping_server, ping_from_dut)
+ for idx, chain in enumerate(rf_map_by_network[net_id]):
+ if chain:
+ rf_map_by_atten[idx].append({
+ 'network': net_id,
+ 'dut_chain': chain
+ })
+ logging.debug('RF Map (by Network): {}'.format(rf_map_by_network))
+ logging.debug('RF Map (by Atten): {}'.format(rf_map_by_atten))
+
+ return rf_map_by_network, rf_map_by_atten
+
+
+# Generic device utils
+def get_dut_temperature(dut):
+ """Function to get dut temperature.
+
+ The function fetches and returns the reading from the temperature sensor
+ used for skin temperature and thermal throttling.
+
+ Args:
+ dut: AndroidDevice of interest
+ Returns:
+ temperature: device temperature. 0 if temperature could not be read
+ """
+ candidate_zones = [
+ '/sys/devices/virtual/thermal/tz-by-name/skin-therm/temp',
+ '/sys/devices/virtual/thermal/tz-by-name/sdm-therm-monitor/temp',
+ '/sys/devices/virtual/thermal/tz-by-name/sdm-therm-adc/temp',
+ '/sys/devices/virtual/thermal/tz-by-name/back_therm/temp',
+ '/dev/thermal/tz-by-name/quiet_therm/temp'
+ ]
+ for zone in candidate_zones:
+ try:
+ temperature = int(dut.adb.shell('cat {}'.format(zone)))
+ break
+ except:
+ temperature = 0
+ if temperature == 0:
+ logging.debug('Could not check DUT temperature.')
+ elif temperature > 100:
+ temperature = temperature / 1000
+ return temperature
+
+
+def wait_for_dut_cooldown(dut, target_temp=50, timeout=300):
+ """Function to wait for a DUT to cool down.
+
+ Args:
+ dut: AndroidDevice of interest
+ target_temp: target cooldown temperature
+ timeout: maxt time to wait for cooldown
+ """
+ start_time = time.time()
+ while time.time() - start_time < timeout:
+ temperature = get_dut_temperature(dut)
+ if temperature < target_temp:
+ break
+ time.sleep(SHORT_SLEEP)
+ elapsed_time = time.time() - start_time
+ logging.debug('DUT Final Temperature: {}C. Cooldown duration: {}'.format(
+ temperature, elapsed_time))
+
+
+def health_check(dut, batt_thresh=5, temp_threshold=53, cooldown=1):
+ """Function to check health status of a DUT.
+
+ The function checks both battery levels and temperature to avoid DUT
+ powering off during the test.
+
+ Args:
+ dut: AndroidDevice of interest
+ batt_thresh: battery level threshold
+ temp_threshold: temperature threshold
+ cooldown: flag to wait for DUT to cool down when overheating
+ Returns:
+ health_check: boolean confirming device is healthy
+ """
+ health_check = True
+ battery_level = utils.get_battery_level(dut)
+ if battery_level < batt_thresh:
+ logging.warning('Battery level low ({}%)'.format(battery_level))
+ health_check = False
+ else:
+ logging.debug('Battery level = {}%'.format(battery_level))
+
+ temperature = get_dut_temperature(dut)
+ if temperature > temp_threshold:
+ if cooldown:
+ logging.warning(
+ 'Waiting for DUT to cooldown. ({} C)'.format(temperature))
+ wait_for_dut_cooldown(dut, target_temp=temp_threshold - 5)
+ else:
+ logging.warning('DUT Overheating ({} C)'.format(temperature))
+ health_check = False
+ else:
+ logging.debug('DUT Temperature = {} C'.format(temperature))
+ return health_check
+
+
+# Wifi Device Utils
+def empty_rssi_result():
+ return collections.OrderedDict([('data', []), ('mean', float('nan')),
+ ('stdev', float('nan'))])
+
+
+@nonblocking
+def get_connected_rssi_nb(dut,
+ num_measurements=1,
+ polling_frequency=SHORT_SLEEP,
+ first_measurement_delay=0,
+ disconnect_warning=True,
+ ignore_samples=0,
+ interface='wlan0'):
+ return get_connected_rssi(dut, num_measurements, polling_frequency,
+ first_measurement_delay, disconnect_warning,
+ ignore_samples, interface)
+
+
+@detect_wifi_decorator
+def get_connected_rssi(dut,
+ num_measurements=1,
+ polling_frequency=SHORT_SLEEP,
+ first_measurement_delay=0,
+ disconnect_warning=True,
+ ignore_samples=0,
+ interface='wlan0'):
+ """Gets all RSSI values reported for the connected access point/BSSID.
+
+ Args:
+ dut: android device object from which to get RSSI
+ num_measurements: number of scans done, and RSSIs collected
+ polling_frequency: time to wait between RSSI measurements
+ disconnect_warning: boolean controlling disconnection logging messages
+ ignore_samples: number of leading samples to ignore
+ Returns:
+ connected_rssi: dict containing the measurements results for
+ all reported RSSI values (signal_poll, per chain, etc.) and their
+ statistics
+ """
+ pass
+
+
+@nonblocking
+def get_scan_rssi_nb(dut, tracked_bssids, num_measurements=1):
+ return get_scan_rssi(dut, tracked_bssids, num_measurements)
+
+
+@detect_wifi_decorator
+def get_scan_rssi(dut, tracked_bssids, num_measurements=1):
+ """Gets scan RSSI for specified BSSIDs.
+
+ Args:
+ dut: android device object from which to get RSSI
+ tracked_bssids: array of BSSIDs to gather RSSI data for
+ num_measurements: number of scans done, and RSSIs collected
+ Returns:
+ scan_rssi: dict containing the measurement results as well as the
+ statistics of the scan RSSI for all BSSIDs in tracked_bssids
+ """
+ pass
+
+
+@detect_wifi_decorator
+def get_sw_signature(dut):
+ """Function that checks the signature for wifi firmware and config files.
+
+ Returns:
+ bdf_signature: signature consisting of last three digits of bdf cksums
+ fw_signature: floating point firmware version, i.e., major.minor
+ """
+ pass
+
+
+@detect_wifi_decorator
+def get_country_code(dut):
+ """Function that returns the current wifi country code."""
+ pass
+
+
+@detect_wifi_decorator
+def push_config(dut, config_file):
+ """Function to push Wifi BDF files
+
+ This function checks for existing wifi bdf files and over writes them all,
+ for simplicity, with the bdf file provided in the arguments. The dut is
+ rebooted for the bdf file to take effect
+
+ Args:
+ dut: dut to push bdf file to
+ config_file: path to bdf_file to push
+ """
+ pass
+
+
+@detect_wifi_decorator
+def start_wifi_logging(dut):
+ """Function to start collecting wifi-related logs"""
+ pass
+
+
+@detect_wifi_decorator
+def stop_wifi_logging(dut):
+ """Function to start collecting wifi-related logs"""
+ pass
+
+
+@detect_wifi_decorator
+def push_firmware(dut, firmware_files):
+ """Function to push Wifi firmware files
+
+ Args:
+ dut: dut to push bdf file to
+ firmware_files: path to wlanmdsp.mbn file
+ datamsc_file: path to Data.msc file
+ """
+ pass
+
+
+@detect_wifi_decorator
+def disable_beamforming(dut):
+ """Function to disable beamforming."""
+ pass
+
+
+@detect_wifi_decorator
+def set_nss_capability(dut, nss):
+ """Function to set number of spatial streams supported."""
+ pass
+
+
+@detect_wifi_decorator
+def set_chain_mask(dut, chain_mask):
+ """Function to set DUT chain mask.
+
+ Args:
+ dut: android device
+ chain_mask: desired chain mask in [0, 1, '2x2']
+ """
+ pass
+
+
+# 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)
+ else:
+ return brcm_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
new file mode 100644
index 0000000..5a8433e
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/bokeh_figure.py
@@ -0,0 +1,361 @@
+#!/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 bokeh, bokeh.plotting, bokeh.io
+import collections
+import itertools
+import json
+import math
+
+
+# Plotting Utilities
+class BokehFigure():
+ """Class enabling simplified Bokeh plotting."""
+
+ COLORS = [
+ 'black',
+ 'blue',
+ 'blueviolet',
+ 'brown',
+ 'burlywood',
+ 'cadetblue',
+ 'cornflowerblue',
+ 'crimson',
+ 'cyan',
+ 'darkblue',
+ 'darkgreen',
+ 'darkmagenta',
+ 'darkorange',
+ 'darkred',
+ 'deepskyblue',
+ 'goldenrod',
+ 'green',
+ 'grey',
+ 'indigo',
+ 'navy',
+ 'olive',
+ 'orange',
+ 'red',
+ 'salmon',
+ 'teal',
+ 'yellow',
+ ]
+ MARKERS = [
+ 'asterisk', 'circle', 'circle_cross', 'circle_x', 'cross', 'diamond',
+ 'diamond_cross', 'hex', 'inverted_triangle', 'square', 'square_x',
+ 'square_cross', 'triangle', 'x'
+ ]
+
+ TOOLS = ('box_zoom,box_select,pan,crosshair,redo,undo,reset,hover,save')
+
+ def __init__(self,
+ title=None,
+ x_label=None,
+ primary_y_label=None,
+ secondary_y_label=None,
+ height=700,
+ width=1100,
+ title_size='15pt',
+ axis_label_size='12pt',
+ legend_label_size='12pt',
+ axis_tick_label_size='12pt',
+ x_axis_type='auto',
+ sizing_mode='scale_both',
+ json_file=None):
+ if json_file:
+ self.load_from_json(json_file)
+ else:
+ self.figure_data = []
+ self.fig_property = {
+ 'title': title,
+ 'x_label': x_label,
+ 'primary_y_label': primary_y_label,
+ 'secondary_y_label': secondary_y_label,
+ 'num_lines': 0,
+ 'height': height,
+ 'width': width,
+ 'title_size': title_size,
+ 'axis_label_size': axis_label_size,
+ 'legend_label_size': legend_label_size,
+ 'axis_tick_label_size': axis_tick_label_size,
+ 'x_axis_type': x_axis_type,
+ 'sizing_mode': sizing_mode
+ }
+
+ 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'],
+ title=self.fig_property['title'],
+ tools=self.TOOLS,
+ x_axis_type=self.fig_property['x_axis_type'],
+ output_backend='webgl')
+ tooltips = [
+ ('index', '$index'),
+ ('(x,y)', '($x, $y)'),
+ ]
+ hover_set = []
+ for line in self.figure_data:
+ hover_set.extend(line['hover_text'].keys())
+ hover_set = set(hover_set)
+ for item in hover_set:
+ tooltips.append((item, '@{}'.format(item)))
+ self.plot.hover.tooltips = tooltips
+ self.plot.add_tools(
+ bokeh.models.tools.WheelZoomTool(dimensions='width'))
+ self.plot.add_tools(
+ bokeh.models.tools.WheelZoomTool(dimensions='height'))
+
+ def _filter_line(self, x_data, y_data, hover_text=None):
+ """Function to remove NaN points from bokeh plots."""
+ x_data_filtered = []
+ y_data_filtered = []
+ hover_text_filtered = {}
+ for idx, xy in enumerate(
+ itertools.zip_longest(x_data, y_data, fillvalue=float('nan'))):
+ if not math.isnan(xy[1]):
+ x_data_filtered.append(xy[0])
+ y_data_filtered.append(xy[1])
+ if hover_text:
+ for key, value in hover_text.items():
+ hover_text_filtered.setdefault(key, [])
+ hover_text_filtered[key].append(
+ value[idx] if len(value) > idx else '')
+ return x_data_filtered, y_data_filtered, hover_text_filtered
+
+ def add_line(self,
+ x_data,
+ y_data,
+ legend,
+ hover_text=None,
+ color=None,
+ width=3,
+ style='solid',
+ marker=None,
+ marker_size=10,
+ shaded_region=None,
+ y_axis='default'):
+ """Function to add line to existing BokehFigure.
+
+ Args:
+ x_data: list containing x-axis values for line
+ y_data: list containing y_axis values for line
+ legend: string containing line title
+ hover_text: text to display when hovering over lines
+ color: string describing line color
+ width: integer line width
+ style: string describing line style, e.g, solid or dashed
+ marker: string specifying line marker, e.g., cross
+ shaded region: data describing shaded region to plot
+ y_axis: identifier for y-axis to plot line against
+ """
+ if y_axis not in ['default', 'secondary']:
+ raise ValueError('y_axis must be default or secondary')
+ if color == None:
+ color = self.COLORS[self.fig_property['num_lines'] %
+ len(self.COLORS)]
+ if style == 'dashed':
+ style = [5, 5]
+ if isinstance(hover_text, list):
+ hover_text = {'info': hover_text}
+ x_data_filter, y_data_filter, hover_text_filter = self._filter_line(
+ x_data, y_data, hover_text)
+ self.figure_data.append({
+ 'x_data': x_data_filter,
+ 'y_data': y_data_filter,
+ 'legend': legend,
+ 'hover_text': hover_text_filter,
+ 'color': color,
+ 'width': width,
+ 'style': style,
+ 'marker': marker,
+ 'marker_size': marker_size,
+ 'shaded_region': shaded_region,
+ 'y_axis': y_axis
+ })
+ self.fig_property['num_lines'] += 1
+
+ def add_scatter(self,
+ x_data,
+ y_data,
+ legend,
+ hover_text=None,
+ color=None,
+ marker=None,
+ marker_size=10,
+ y_axis='default'):
+ """Function to add line to existing BokehFigure.
+
+ Args:
+ x_data: list containing x-axis values for line
+ y_data: list containing y_axis values for line
+ legend: string containing line title
+ hover_text: text to display when hovering over lines
+ color: string describing line color
+ marker: string specifying marker, e.g., cross
+ y_axis: identifier for y-axis to plot line against
+ """
+ if y_axis not in ['default', 'secondary']:
+ raise ValueError('y_axis must be default or secondary')
+ if color == None:
+ color = self.COLORS[self.fig_property['num_lines'] %
+ len(self.COLORS)]
+ if marker == None:
+ marker = self.MARKERS[self.fig_property['num_lines'] %
+ len(self.MARKERS)]
+ self.figure_data.append({
+ 'x_data': x_data,
+ 'y_data': y_data,
+ 'legend': legend,
+ 'hover_text': hover_text,
+ 'color': color,
+ 'width': 0,
+ 'style': 'solid',
+ 'marker': marker,
+ 'marker_size': marker_size,
+ 'shaded_region': None,
+ 'y_axis': y_axis
+ })
+ self.fig_property['num_lines'] += 1
+
+ def generate_figure(self, output_file=None, save_json=True):
+ """Function to generate and save BokehFigure.
+
+ Args:
+ output_file: string specifying output file path
+ """
+ self.init_plot()
+ two_axes = False
+ for line in self.figure_data:
+ data_dict = {'x': line['x_data'], 'y': line['y_data']}
+ for key, value in line['hover_text'].items():
+ data_dict[key] = value
+ source = bokeh.models.ColumnDataSource(data=data_dict)
+ if line['width'] > 0:
+ self.plot.line(x='x',
+ y='y',
+ legend_label=line['legend'],
+ line_width=line['width'],
+ color=line['color'],
+ line_dash=line['style'],
+ name=line['y_axis'],
+ y_range_name=line['y_axis'],
+ source=source)
+ if line['shaded_region']:
+ band_x = line['shaded_region']['x_vector']
+ band_x.extend(line['shaded_region']['x_vector'][::-1])
+ band_y = line['shaded_region']['lower_limit']
+ band_y.extend(line['shaded_region']['upper_limit'][::-1])
+ self.plot.patch(band_x,
+ band_y,
+ color='#7570B3',
+ line_alpha=0.1,
+ fill_alpha=0.1)
+ if line['marker'] in self.MARKERS:
+ marker_func = getattr(self.plot, line['marker'])
+ marker_func(x='x',
+ y='y',
+ size=line['marker_size'],
+ legend_label=line['legend'],
+ line_color=line['color'],
+ fill_color=line['color'],
+ name=line['y_axis'],
+ y_range_name=line['y_axis'],
+ source=source)
+ if line['y_axis'] == 'secondary':
+ two_axes = True
+
+ #x-axis formatting
+ self.plot.xaxis.axis_label = self.fig_property['x_label']
+ self.plot.x_range.range_padding = 0
+ self.plot.xaxis[0].axis_label_text_font_size = self.fig_property[
+ 'axis_label_size']
+ self.plot.xaxis.major_label_text_font_size = self.fig_property[
+ 'axis_tick_label_size']
+ #y-axis formatting
+ self.plot.yaxis[0].axis_label = self.fig_property['primary_y_label']
+ self.plot.yaxis[0].axis_label_text_font_size = self.fig_property[
+ 'axis_label_size']
+ self.plot.yaxis.major_label_text_font_size = self.fig_property[
+ 'axis_tick_label_size']
+ self.plot.y_range = bokeh.models.DataRange1d(names=['default'])
+ if two_axes and 'secondary' not in self.plot.extra_y_ranges:
+ self.plot.extra_y_ranges = {
+ 'secondary': bokeh.models.DataRange1d(names=['secondary'])
+ }
+ self.plot.add_layout(
+ bokeh.models.LinearAxis(
+ y_range_name='secondary',
+ axis_label=self.fig_property['secondary_y_label'],
+ axis_label_text_font_size=self.
+ fig_property['axis_label_size']), 'right')
+ # plot formatting
+ self.plot.legend.location = 'top_right'
+ self.plot.legend.click_policy = 'hide'
+ self.plot.title.text_font_size = self.fig_property['title_size']
+ self.plot.legend.label_text_font_size = self.fig_property[
+ 'legend_label_size']
+
+ if output_file is not None:
+ self.save_figure(output_file, save_json)
+ return self.plot
+
+ def load_from_json(self, file_path):
+ with open(file_path, 'r') as json_file:
+ fig_dict = json.load(json_file)
+ self.fig_property = fig_dict['fig_property']
+ self.figure_data = fig_dict['figure_data']
+
+ def _save_figure_json(self, output_file):
+ """Function to save a json format of a figure"""
+ figure_dict = collections.OrderedDict(fig_property=self.fig_property,
+ 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)
+
+ def save_figure(self, output_file, save_json=True):
+ """Function to save BokehFigure.
+
+ Args:
+ output_file: string specifying output file path
+ save_json: flag controlling json outputs
+ """
+ if save_json:
+ self._save_figure_json(output_file)
+ bokeh.io.output_file(output_file)
+ bokeh.io.save(self.plot)
+
+ @staticmethod
+ def save_figures(figure_array, output_file_path, save_json=True):
+ """Function to save list of BokehFigures in one file.
+
+ Args:
+ figure_array: list of BokehFigure object to be plotted
+ output_file: string specifying output file path
+ """
+ for idx, figure in enumerate(figure_array):
+ figure.generate_figure()
+ if save_json:
+ json_file_path = output_file_path.replace(
+ '.html', '{}-plot_data.json'.format(idx))
+ figure._save_figure_json(json_file_path)
+ plot_array = [figure.plot for figure in figure_array]
+ all_plots = bokeh.layouts.column(children=plot_array,
+ sizing_mode='scale_width')
+ bokeh.plotting.output_file(output_file_path)
+ bokeh.plotting.save(all_plots)
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
new file mode 100644
index 0000000..afa5f32
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/brcm_utils.py
@@ -0,0 +1,578 @@
+#!/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 hashlib
+import itertools
+import logging
+import math
+import numpy
+import re
+import statistics
+import time
+
+VERY_SHORT_SLEEP = 0.5
+SHORT_SLEEP = 1
+MED_SLEEP = 6
+DISCONNECTION_MESSAGE_BRCM = 'driver adapter not found'
+RSSI_ERROR_VAL = float('nan')
+RATE_TABLE = {
+ 'HT': {
+ 1: {
+ 20: [7.2, 14.4, 21.7, 28.9, 43.4, 57.8, 65.0, 72.2],
+ 40: [15.0, 30.0, 45.0, 60.0, 90.0, 120.0, 135.0, 150.0]
+ },
+ 2: {
+ 20: [
+ 0, 0, 0, 0, 0, 0, 0, 0, 14.4, 28.8, 43.4, 57.8, 86.8, 115.6,
+ 130, 144.4
+ ],
+ 40: [0, 0, 0, 0, 0, 0, 0, 0, 30, 60, 90, 120, 180, 240, 270, 300]
+ }
+ },
+ 'VHT': {
+ 1: {
+ 20: [
+ 7.2, 14.4, 21.7, 28.9, 43.4, 57.8, 65.0, 72.2, 86.7, 96.2,
+ 129.0, 143.4
+ ],
+ 40: [
+ 15.0, 30.0, 45.0, 60.0, 90.0, 120.0, 135.0, 150.0, 180.0,
+ 200.0, 258, 286.8
+ ],
+ 80: [
+ 32.5, 65.0, 97.5, 130.0, 195.0, 260.0, 292.5, 325.0, 390.0,
+ 433.3, 540.4, 600.4
+ ],
+ 160: [
+ 65.0, 130.0, 195.0, 260.0, 390.0, 520.0, 585.0, 650.0, 780.0,
+ 1080.8, 1200.8
+ ]
+ },
+ 2: {
+ 20: [
+ 14.4, 28.8, 43.4, 57.8, 86.8, 115.6, 130, 144.4, 173.4, 192.4,
+ 258, 286.8
+ ],
+ 40: [30, 60, 90, 120, 180, 240, 270, 300, 360, 400, 516, 573.6],
+ 80: [
+ 65, 130, 195, 260, 390, 520, 585, 650, 780, 866.6, 1080.8,
+ 1200.8
+ ],
+ 160:
+ [130, 260, 390, 520, 780, 1040, 1170, 1300, 1560, 2161.6, 2401.6]
+ },
+ },
+ 'HE': {
+ 1: {
+ 20: [
+ 8.6, 17.2, 25.8, 34.4, 51.6, 68.8, 77.4, 86.0, 103.2, 114.7,
+ 129.0, 143.4
+ ],
+ 40: [
+ 17.2, 34.4, 51.6, 68.8, 103.2, 137.6, 154.8, 172, 206.4, 229.4,
+ 258, 286.8
+ ],
+ 80: [
+ 36.0, 72.1, 108.1, 144.1, 216.2, 288.2, 324.3, 360.3, 432.4,
+ 480.4, 540.4, 600.4
+ ],
+ 160: [
+ 72, 144.2, 216.2, 288.2, 432.4, 576.4, 648.6, 720.6, 864.8,
+ 960.8, 1080.8, 1200.8
+ ]
+ },
+ 2: {
+ 20: [
+ 17.2, 34.4, 51.6, 68.8, 103.2, 137.6, 154.8, 172, 206.4, 229.4,
+ 258, 286.8
+ ],
+ 40: [
+ 34.4, 68.8, 103.2, 137.6, 206.4, 275.2, 309.6, 344, 412.8,
+ 458.8, 516, 573.6
+ ],
+ 80: [
+ 72, 144.2, 216.2, 288.2, 432.4, 576.4, 648.6, 720.6, 864.8,
+ 960.8, 1080.8, 1200.8
+ ],
+ 160: [
+ 144, 288.4, 432.4, 576.4, 864.8, 1152.8, 1297.2, 1441.2,
+ 1729.6, 1921.6, 2161.6, 2401.6
+ ]
+ },
+ },
+}
+
+
+# Rssi Utilities
+def empty_rssi_result():
+ return collections.OrderedDict([('data', []), ('mean', None),
+ ('stdev', None)])
+
+
+def get_connected_rssi(dut,
+ num_measurements=1,
+ polling_frequency=SHORT_SLEEP,
+ first_measurement_delay=0,
+ disconnect_warning=True,
+ ignore_samples=0,
+ interface='wlan0'):
+ # yapf: disable
+ connected_rssi = collections.OrderedDict(
+ [('time_stamp', []),
+ ('bssid', []), ('ssid', []), ('frequency', []),
+ ('signal_poll_rssi', empty_rssi_result()),
+ ('signal_poll_avg_rssi', empty_rssi_result()),
+ ('chain_0_rssi', empty_rssi_result()),
+ ('chain_1_rssi', empty_rssi_result())])
+
+ # yapf: enable
+ previous_bssid = 'disconnected'
+ t0 = time.time()
+ time.sleep(first_measurement_delay)
+ for idx in range(num_measurements):
+ measurement_start_time = time.time()
+ connected_rssi['time_stamp'].append(measurement_start_time - t0)
+ # Get signal poll RSSI
+ try:
+ status_output = dut.adb.shell(
+ 'wpa_cli -i {} status'.format(interface))
+ except:
+ status_output = ''
+ match = re.search('bssid=.*', status_output)
+ if match:
+ current_bssid = match.group(0).split('=')[1]
+ connected_rssi['bssid'].append(current_bssid)
+ else:
+ current_bssid = 'disconnected'
+ connected_rssi['bssid'].append(current_bssid)
+ if disconnect_warning and previous_bssid != 'disconnected':
+ logging.warning('WIFI DISCONNECT DETECTED!')
+
+ previous_bssid = current_bssid
+ match = re.search('\s+ssid=.*', status_output)
+ if match:
+ ssid = match.group(0).split('=')[1]
+ connected_rssi['ssid'].append(ssid)
+ else:
+ connected_rssi['ssid'].append('disconnected')
+
+ #TODO: SEARCH MAP ; PICK CENTER CHANNEL
+ match = re.search('\s+freq=.*', status_output)
+ if match:
+ frequency = int(match.group(0).split('=')[1])
+ connected_rssi['frequency'].append(frequency)
+ else:
+ connected_rssi['frequency'].append(RSSI_ERROR_VAL)
+
+ if interface == 'wlan0':
+ try:
+ per_chain_rssi = dut.adb.shell('wl phy_rssi_ant')
+ chain_0_rssi = re.search(
+ r'rssi\[0\]\s(?P<chain_0_rssi>[0-9\-]*)', per_chain_rssi)
+ if chain_0_rssi:
+ chain_0_rssi = int(chain_0_rssi.group('chain_0_rssi'))
+ else:
+ chain_0_rssi = -float('inf')
+ chain_1_rssi = re.search(
+ r'rssi\[1\]\s(?P<chain_1_rssi>[0-9\-]*)', per_chain_rssi)
+ if chain_1_rssi:
+ chain_1_rssi = int(chain_1_rssi.group('chain_1_rssi'))
+ else:
+ chain_1_rssi = -float('inf')
+ except:
+ chain_0_rssi = RSSI_ERROR_VAL
+ chain_1_rssi = RSSI_ERROR_VAL
+ connected_rssi['chain_0_rssi']['data'].append(chain_0_rssi)
+ connected_rssi['chain_1_rssi']['data'].append(chain_1_rssi)
+ combined_rssi = math.pow(10, chain_0_rssi / 10) + math.pow(
+ 10, chain_1_rssi / 10)
+ combined_rssi = 10 * math.log10(combined_rssi)
+ connected_rssi['signal_poll_rssi']['data'].append(combined_rssi)
+ connected_rssi['signal_poll_avg_rssi']['data'].append(
+ combined_rssi)
+ else:
+ try:
+ signal_poll_output = dut.adb.shell(
+ 'wpa_cli -i {} signal_poll'.format(interface))
+ except:
+ signal_poll_output = ''
+ match = re.search('RSSI=.*', signal_poll_output)
+ if match:
+ temp_rssi = int(match.group(0).split('=')[1])
+ if temp_rssi == -9999 or temp_rssi == 0:
+ connected_rssi['signal_poll_rssi']['data'].append(
+ RSSI_ERROR_VAL)
+ else:
+ connected_rssi['signal_poll_rssi']['data'].append(
+ temp_rssi)
+ else:
+ connected_rssi['signal_poll_rssi']['data'].append(
+ RSSI_ERROR_VAL)
+ connected_rssi['chain_0_rssi']['data'].append(RSSI_ERROR_VAL)
+ connected_rssi['chain_1_rssi']['data'].append(RSSI_ERROR_VAL)
+ measurement_elapsed_time = time.time() - measurement_start_time
+ time.sleep(max(0, polling_frequency - measurement_elapsed_time))
+
+ # Statistics, Statistics
+ for key, val in connected_rssi.copy().items():
+ if 'data' not in val:
+ continue
+ filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
+ if len(filtered_rssi_values) > ignore_samples:
+ filtered_rssi_values = filtered_rssi_values[ignore_samples:]
+ if filtered_rssi_values:
+ connected_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
+ if len(filtered_rssi_values) > 1:
+ connected_rssi[key]['stdev'] = statistics.stdev(
+ filtered_rssi_values)
+ else:
+ connected_rssi[key]['stdev'] = 0
+ else:
+ connected_rssi[key]['mean'] = RSSI_ERROR_VAL
+ connected_rssi[key]['stdev'] = RSSI_ERROR_VAL
+
+ return connected_rssi
+
+
+def get_scan_rssi(dut, tracked_bssids, num_measurements=1):
+ scan_rssi = collections.OrderedDict()
+ for bssid in tracked_bssids:
+ scan_rssi[bssid] = empty_rssi_result()
+ for idx in range(num_measurements):
+ scan_output = dut.adb.shell('cmd wifi start-scan')
+ time.sleep(MED_SLEEP)
+ scan_output = dut.adb.shell('cmd wifi list-scan-results')
+ for bssid in tracked_bssids:
+ bssid_result = re.search(bssid + '.*',
+ scan_output,
+ flags=re.IGNORECASE)
+ if bssid_result:
+ bssid_result = bssid_result.group(0).split()
+ scan_rssi[bssid]['data'].append(int(bssid_result[2]))
+ else:
+ scan_rssi[bssid]['data'].append(RSSI_ERROR_VAL)
+ # Compute mean RSSIs. Only average valid readings.
+ # Output RSSI_ERROR_VAL if no readings found.
+ for key, val in scan_rssi.items():
+ filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
+ if filtered_rssi_values:
+ scan_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
+ if len(filtered_rssi_values) > 1:
+ scan_rssi[key]['stdev'] = statistics.stdev(
+ filtered_rssi_values)
+ else:
+ scan_rssi[key]['stdev'] = 0
+ else:
+ scan_rssi[key]['mean'] = RSSI_ERROR_VAL
+ scan_rssi[key]['stdev'] = RSSI_ERROR_VAL
+ return scan_rssi
+
+
+def get_sw_signature(dut):
+ bdf_output = dut.adb.shell('cksum /vendor/firmware/bcmdhd*')
+ logging.debug('BDF Checksum output: {}'.format(bdf_output))
+ bdf_signature = sum(
+ [int(line.split(' ')[0]) for line in bdf_output.splitlines()]) % 1000
+
+ fw_version = dut.adb.shell('getprop vendor.wlan.firmware.version')
+ driver_version = dut.adb.shell('getprop vendor.wlan.driver.version')
+ logging.debug('Firmware version : {}. Driver version: {}'.format(
+ fw_version, driver_version))
+ fw_signature = '{}+{}'.format(fw_version, driver_version)
+ fw_signature = int(hashlib.md5(fw_signature.encode()).hexdigest(),
+ 16) % 1000
+ serial_hash = int(hashlib.md5(dut.serial.encode()).hexdigest(), 16) % 1000
+ return {
+ 'config_signature': bdf_signature,
+ 'fw_signature': fw_signature,
+ 'serial_hash': serial_hash
+ }
+
+
+def get_country_code(dut):
+ try:
+ country_code = dut.adb.shell('wl country').split(' ')[0]
+ except:
+ country_code = 'XZ'
+ if country_code == 'XZ':
+ country_code = 'WW'
+ logging.debug('Country code: {}'.format(country_code))
+ return country_code
+
+
+def push_config(dut, config_file):
+ config_files_list = dut.adb.shell('ls /vendor/etc/*.cal').splitlines()
+ for dst_file in config_files_list:
+ dut.push_system_file(config_file, dst_file)
+ dut.reboot()
+
+
+def start_wifi_logging(dut):
+ pass
+
+
+def stop_wifi_logging(dut):
+ pass
+
+
+def push_firmware(dut, firmware_files):
+ """Function to push Wifi firmware files
+
+ Args:
+ dut: dut to push bdf file to
+ firmware_files: path to wlanmdsp.mbn file
+ datamsc_file: path to Data.msc file
+ """
+ for file in firmware_files:
+ dut.push_system_file(file, '/vendor/firmware/')
+ dut.reboot()
+
+
+def disable_beamforming(dut):
+ dut.adb.shell('wl txbf 0')
+
+
+def set_nss_capability(dut, nss):
+ dut.adb.shell('wl he omi -r {} -t {}'.format(nss, nss))
+
+
+def set_chain_mask(dut, chain):
+ if chain == '2x2':
+ chain = 3
+ else:
+ chain = chain + 1
+ # Get current chain mask
+ try:
+ curr_tx_chain = int(dut.adb.shell('wl txchain'))
+ curr_rx_chain = int(dut.adb.shell('wl rxchain'))
+ except:
+ curr_tx_chain = -1
+ curr_rx_chain = -1
+ if curr_tx_chain == chain and curr_rx_chain == chain:
+ return
+ # Set chain mask if needed
+ dut.adb.shell('wl down')
+ time.sleep(VERY_SHORT_SLEEP)
+ dut.adb.shell('wl txchain 0x{}'.format(chain))
+ dut.adb.shell('wl rxchain 0x{}'.format(chain))
+ dut.adb.shell('wl up')
+
+
+class LinkLayerStats():
+
+ LLSTATS_CMD = 'wl dump ampdu; wl counters;'
+ 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, ,(,),%]*)')
+ 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_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(
+ r'agg stop reason: tot_agg_tried (?P<agg_tried>[0-9]+) agg_txcancel (?P<agg_canceled>[0-9]+) (?P<agg_stop_reason>.+)'
+ )
+ TX_AGG_STOP_REASON_REGEX = re.compile(
+ r'(?P<reason>\w+) [0-9]+ \((?P<value>[0-9]+%)\)')
+ MCS_ID = collections.namedtuple(
+ 'mcs_id', ['mode', 'num_streams', 'bandwidth', 'mcs', 'gi'])
+ MODE_MAP = {'0': '11a/g', '1': '11b', '2': '11n', '3': '11ac'}
+ BW_MAP = {'0': 20, '1': 40, '2': 80}
+
+ def __init__(self, dut, llstats_enabled=True):
+ self.dut = dut
+ self.llstats_enabled = llstats_enabled
+ self.llstats_cumulative = self._empty_llstats()
+ self.llstats_incremental = self._empty_llstats()
+
+ def update_stats(self):
+ if self.llstats_enabled:
+ try:
+ llstats_output = self.dut.adb.shell(self.LLSTATS_CMD,
+ timeout=1)
+ 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'))
+ except:
+ llstats_output = ''
+ else:
+ llstats_output = ''
+ self._update_stats(llstats_output)
+
+ def reset_stats(self):
+ self.llstats_cumulative = self._empty_llstats()
+ self.llstats_incremental = self._empty_llstats()
+
+ def _empty_llstats(self):
+ return collections.OrderedDict(mcs_stats=collections.OrderedDict(),
+ mpdu_stats=collections.OrderedDict(),
+ summary=collections.OrderedDict())
+
+ def _empty_mcs_stat(self):
+ return collections.OrderedDict(txmpdu=0,
+ rxmpdu=0,
+ mpdu_lost=0,
+ retries=0,
+ retries_short=0,
+ retries_long=0)
+
+ def _mcs_id_to_string(self, mcs_id):
+ mcs_string = '{} Nss{} MCS{} GI{}'.format(mcs_id.mode,
+ mcs_id.num_streams,
+ mcs_id.mcs, mcs_id.gi)
+ return mcs_string
+
+ def _parse_mcs_stats(self, llstats_output):
+ llstats_dict = {}
+ # Look for per-peer stats
+ match = re.search(self.RX_REGEX, llstats_output)
+ if not match:
+ self.reset_stats()
+ return collections.OrderedDict()
+ # Find and process all matches for per stream stats
+ rx_match_iter = re.finditer(self.RX_REGEX, llstats_output)
+ tx_match_iter = re.finditer(self.TX_REGEX, llstats_output)
+ tx_per_match_iter = re.finditer(self.TX_PER_REGEX, llstats_output)
+ for rx_match, tx_match, tx_per_match in zip(rx_match_iter,
+ tx_match_iter,
+ tx_per_match_iter):
+ mode = rx_match.group('mode')
+ mode = 'HT' if mode == 'MCS' else mode
+ for nss in [1, 2]:
+ rx_mcs_iter = re.finditer(self.MCS_REGEX,
+ rx_match.group(nss + 1))
+ tx_mcs_iter = re.finditer(self.MCS_REGEX,
+ tx_match.group(nss + 1))
+ tx_per_iter = re.finditer(self.MCS_REGEX,
+ tx_per_match.group(nss + 1))
+ for mcs, (rx_mcs_stats, tx_mcs_stats,
+ tx_per_mcs_stats) in enumerate(
+ itertools.zip_longest(rx_mcs_iter, tx_mcs_iter,
+ tx_per_iter)):
+ current_mcs = self.MCS_ID(
+ mode, nss, self.bandwidth,
+ mcs + int(8 * (mode == 'HT') * (nss - 1)), 0)
+ current_stats = collections.OrderedDict(
+ txmpdu=int(tx_mcs_stats.group('count'))
+ if tx_mcs_stats else 0,
+ rxmpdu=int(rx_mcs_stats.group('count'))
+ if rx_mcs_stats else 0,
+ mpdu_lost=0,
+ retries=tx_per_mcs_stats.group('count')
+ if tx_per_mcs_stats else 0,
+ retries_short=0,
+ retries_long=0,
+ mcs_id=current_mcs)
+ llstats_dict[self._mcs_id_to_string(
+ current_mcs)] = current_stats
+ return llstats_dict
+
+ def _parse_mpdu_stats(self, llstats_output):
+ 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)
+
+ 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())
+ 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(
+ '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
+
+ def _generate_stats_summary(self, llstats_dict):
+ llstats_summary = collections.OrderedDict(common_tx_mcs=None,
+ common_tx_mcs_count=0,
+ common_tx_mcs_freq=0,
+ common_rx_mcs=None,
+ common_rx_mcs_count=0,
+ common_rx_mcs_freq=0,
+ rx_per=float('nan'))
+ mcs_ids = []
+ tx_mpdu = []
+ rx_mpdu = []
+ phy_rates = []
+ for mcs_str, mcs_stats in llstats_dict['mcs_stats'].items():
+ mcs_id = mcs_stats['mcs_id']
+ mcs_ids.append(mcs_str)
+ tx_mpdu.append(mcs_stats['txmpdu'])
+ rx_mpdu.append(mcs_stats['rxmpdu'])
+ phy_rates.append(RATE_TABLE[mcs_id.mode][mcs_id.num_streams][
+ mcs_id.bandwidth][mcs_id.mcs])
+ if len(tx_mpdu) == 0 or len(rx_mpdu) == 0:
+ return llstats_summary
+ llstats_summary['common_tx_mcs'] = mcs_ids[numpy.argmax(tx_mpdu)]
+ 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):
+ 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))
+ llstats_summary['common_rx_mcs_freq'] = (
+ llstats_summary['common_rx_mcs_count'] / sum(rx_mpdu))
+ total_rx_frames = llstats_dict['mpdu_stats'][
+ 'rx_good_fcs'] + llstats_dict['mpdu_stats']['rx_bad_fcs']
+ if total_rx_frames:
+ llstats_summary['rx_per'] = (
+ llstats_dict['mpdu_stats']['rx_bad_fcs'] /
+ (total_rx_frames)) * 100
+ return llstats_summary
+
+ def _update_stats(self, llstats_output):
+ self.llstats_cumulative = self._empty_llstats()
+ self.llstats_incremental = self._empty_llstats()
+ self.llstats_incremental['raw_output'] = llstats_output
+ self.llstats_incremental['mcs_stats'] = self._parse_mcs_stats(
+ llstats_output)
+ self.llstats_incremental['mpdu_stats'] = self._parse_mpdu_stats(
+ llstats_output)
+ self.llstats_incremental['summary'] = self._generate_stats_summary(
+ self.llstats_incremental)
+ self.llstats_cumulative['summary'] = self._generate_stats_summary(
+ self.llstats_cumulative)
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/ping_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/ping_utils.py
new file mode 100644
index 0000000..7d2e09f
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/ping_utils.py
@@ -0,0 +1,125 @@
+#!/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 re
+
+RTT_REGEX = re.compile(r'^\[(?P<timestamp>\S+)\] .*? time=(?P<rtt>\S+)')
+LOSS_REGEX = re.compile(r'(?P<loss>\S+)% packet loss')
+
+
+class PingResult(object):
+ """An object that contains the results of running ping command.
+
+ Attributes:
+ connected: True if a connection was made. False otherwise.
+ packet_loss_percentage: The total percentage of packets lost.
+ transmission_times: The list of PingTransmissionTimes containing the
+ timestamps gathered for transmitted packets.
+ rtts: An list-like object enumerating all round-trip-times of
+ transmitted packets.
+ timestamps: A list-like object enumerating the beginning timestamps of
+ each packet transmission.
+ ping_interarrivals: A list-like object enumerating the amount of time
+ between the beginning of each subsequent transmission.
+ """
+ def __init__(self, ping_output):
+ self.packet_loss_percentage = 100
+ self.transmission_times = []
+
+ self.rtts = _ListWrap(self.transmission_times, lambda entry: entry.rtt)
+ self.timestamps = _ListWrap(self.transmission_times,
+ lambda entry: entry.timestamp)
+ self.ping_interarrivals = _PingInterarrivals(self.transmission_times)
+
+ self.start_time = 0
+ for line in ping_output:
+ if 'loss' in line:
+ match = re.search(LOSS_REGEX, line)
+ self.packet_loss_percentage = float(match.group('loss'))
+ if 'time=' in line:
+ match = re.search(RTT_REGEX, line)
+ if self.start_time == 0:
+ self.start_time = float(match.group('timestamp'))
+ self.transmission_times.append(
+ PingTransmissionTimes(
+ float(match.group('timestamp')) - self.start_time,
+ float(match.group('rtt'))))
+ self.connected = len(
+ ping_output) > 1 and self.packet_loss_percentage < 100
+
+ def __getitem__(self, item):
+ if item == 'rtt':
+ return self.rtts
+ if item == 'connected':
+ return self.connected
+ if item == 'packet_loss_percentage':
+ return self.packet_loss_percentage
+ raise ValueError('Invalid key. Please use an attribute instead.')
+
+ def as_dict(self):
+ return {
+ 'connected': 1 if self.connected else 0,
+ 'rtt': list(self.rtts),
+ 'time_stamp': list(self.timestamps),
+ 'ping_interarrivals': list(self.ping_interarrivals),
+ 'packet_loss_percentage': self.packet_loss_percentage
+ }
+
+
+class PingTransmissionTimes(object):
+ """A class that holds the timestamps for a packet sent via the ping command.
+
+ Attributes:
+ rtt: The round trip time for the packet sent.
+ timestamp: The timestamp the packet started its trip.
+ """
+ def __init__(self, timestamp, rtt):
+ self.rtt = rtt
+ self.timestamp = timestamp
+
+
+class _ListWrap(object):
+ """A convenient helper class for treating list iterators as native lists."""
+ def __init__(self, wrapped_list, func):
+ self.__wrapped_list = wrapped_list
+ self.__func = func
+
+ def __getitem__(self, key):
+ return self.__func(self.__wrapped_list[key])
+
+ def __iter__(self):
+ for item in self.__wrapped_list:
+ yield self.__func(item)
+
+ def __len__(self):
+ return len(self.__wrapped_list)
+
+
+class _PingInterarrivals(object):
+ """A helper class for treating ping interarrivals as a native list."""
+ def __init__(self, ping_entries):
+ self.__ping_entries = ping_entries
+
+ def __getitem__(self, key):
+ return (self.__ping_entries[key + 1].timestamp -
+ self.__ping_entries[key].timestamp)
+
+ def __iter__(self):
+ for index in range(len(self.__ping_entries) - 1):
+ yield self[index]
+
+ def __len__(self):
+ return max(0, len(self.__ping_entries) - 1)
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
new file mode 100644
index 0000000..53321bc
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_performance_test_utils/qcom_utils.py
@@ -0,0 +1,467 @@
+#!/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 hashlib
+import logging
+import math
+import os
+import re
+import statistics
+import time
+from acts import asserts
+
+SHORT_SLEEP = 1
+MED_SLEEP = 6
+STATION_DUMP = 'iw {} station dump'
+SCAN = 'wpa_cli scan'
+SCAN_RESULTS = 'wpa_cli scan_results'
+SIGNAL_POLL = 'wpa_cli signal_poll'
+WPA_CLI_STATUS = 'wpa_cli status'
+RSSI_ERROR_VAL = float('nan')
+FW_REGEX = re.compile(r'FW:(?P<firmware>\S+) HW:')
+
+
+# Rssi Utilities
+def empty_rssi_result():
+ return collections.OrderedDict([('data', []), ('mean', None),
+ ('stdev', None)])
+
+
+def get_connected_rssi(dut,
+ num_measurements=1,
+ polling_frequency=SHORT_SLEEP,
+ first_measurement_delay=0,
+ disconnect_warning=True,
+ ignore_samples=0,
+ interface='wlan0'):
+ # yapf: disable
+ connected_rssi = collections.OrderedDict(
+ [('time_stamp', []),
+ ('bssid', []), ('ssid', []), ('frequency', []),
+ ('signal_poll_rssi', empty_rssi_result()),
+ ('signal_poll_avg_rssi', empty_rssi_result()),
+ ('chain_0_rssi', empty_rssi_result()),
+ ('chain_1_rssi', empty_rssi_result())])
+ # yapf: enable
+ previous_bssid = 'disconnected'
+ t0 = time.time()
+ time.sleep(first_measurement_delay)
+ for idx in range(num_measurements):
+ measurement_start_time = time.time()
+ connected_rssi['time_stamp'].append(measurement_start_time - t0)
+ # Get signal poll RSSI
+ try:
+ status_output = dut.adb.shell(
+ 'wpa_cli -i {} status'.format(interface))
+ except:
+ status_output = ''
+ match = re.search('bssid=.*', status_output)
+ if match:
+ current_bssid = match.group(0).split('=')[1]
+ connected_rssi['bssid'].append(current_bssid)
+ else:
+ current_bssid = 'disconnected'
+ connected_rssi['bssid'].append(current_bssid)
+ if disconnect_warning and previous_bssid != 'disconnected':
+ logging.warning('WIFI DISCONNECT DETECTED!')
+ previous_bssid = current_bssid
+ match = re.search('\s+ssid=.*', status_output)
+ if match:
+ ssid = match.group(0).split('=')[1]
+ connected_rssi['ssid'].append(ssid)
+ else:
+ connected_rssi['ssid'].append('disconnected')
+ try:
+ signal_poll_output = dut.adb.shell(
+ 'wpa_cli -i {} signal_poll'.format(interface))
+ except:
+ signal_poll_output = ''
+ match = re.search('FREQUENCY=.*', signal_poll_output)
+ if match:
+ frequency = int(match.group(0).split('=')[1])
+ connected_rssi['frequency'].append(frequency)
+ else:
+ connected_rssi['frequency'].append(RSSI_ERROR_VAL)
+ match = re.search('RSSI=.*', signal_poll_output)
+ if match:
+ temp_rssi = int(match.group(0).split('=')[1])
+ if temp_rssi == -9999 or temp_rssi == 0:
+ connected_rssi['signal_poll_rssi']['data'].append(
+ RSSI_ERROR_VAL)
+ else:
+ connected_rssi['signal_poll_rssi']['data'].append(temp_rssi)
+ else:
+ connected_rssi['signal_poll_rssi']['data'].append(RSSI_ERROR_VAL)
+ match = re.search('AVG_RSSI=.*', signal_poll_output)
+ if match:
+ connected_rssi['signal_poll_avg_rssi']['data'].append(
+ int(match.group(0).split('=')[1]))
+ else:
+ connected_rssi['signal_poll_avg_rssi']['data'].append(
+ RSSI_ERROR_VAL)
+
+ # Get per chain RSSI
+ try:
+ per_chain_rssi = dut.adb.shell(STATION_DUMP.format(interface))
+ except:
+ per_chain_rssi = ''
+ match = re.search('.*signal avg:.*', per_chain_rssi)
+ if match:
+ per_chain_rssi = per_chain_rssi[per_chain_rssi.find('[') +
+ 1:per_chain_rssi.find(']')]
+ per_chain_rssi = per_chain_rssi.split(', ')
+ connected_rssi['chain_0_rssi']['data'].append(
+ int(per_chain_rssi[0]))
+ connected_rssi['chain_1_rssi']['data'].append(
+ int(per_chain_rssi[1]))
+ else:
+ connected_rssi['chain_0_rssi']['data'].append(RSSI_ERROR_VAL)
+ connected_rssi['chain_1_rssi']['data'].append(RSSI_ERROR_VAL)
+ measurement_elapsed_time = time.time() - measurement_start_time
+ time.sleep(max(0, polling_frequency - measurement_elapsed_time))
+
+ # Compute mean RSSIs. Only average valid readings.
+ # Output RSSI_ERROR_VAL if no valid connected readings found.
+ for key, val in connected_rssi.copy().items():
+ if 'data' not in val:
+ continue
+ filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
+ if len(filtered_rssi_values) > ignore_samples:
+ filtered_rssi_values = filtered_rssi_values[ignore_samples:]
+ if filtered_rssi_values:
+ connected_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
+ if len(filtered_rssi_values) > 1:
+ connected_rssi[key]['stdev'] = statistics.stdev(
+ filtered_rssi_values)
+ else:
+ connected_rssi[key]['stdev'] = 0
+ else:
+ connected_rssi[key]['mean'] = RSSI_ERROR_VAL
+ connected_rssi[key]['stdev'] = RSSI_ERROR_VAL
+ return connected_rssi
+
+
+def get_scan_rssi(dut, tracked_bssids, num_measurements=1):
+ scan_rssi = collections.OrderedDict()
+ for bssid in tracked_bssids:
+ scan_rssi[bssid] = empty_rssi_result()
+ for idx in range(num_measurements):
+ scan_output = dut.adb.shell(SCAN)
+ time.sleep(MED_SLEEP)
+ scan_output = dut.adb.shell(SCAN_RESULTS)
+ for bssid in tracked_bssids:
+ bssid_result = re.search(bssid + '.*',
+ scan_output,
+ flags=re.IGNORECASE)
+ if bssid_result:
+ bssid_result = bssid_result.group(0).split('\t')
+ scan_rssi[bssid]['data'].append(int(bssid_result[2]))
+ else:
+ scan_rssi[bssid]['data'].append(RSSI_ERROR_VAL)
+ # Compute mean RSSIs. Only average valid readings.
+ # Output RSSI_ERROR_VAL if no readings found.
+ for key, val in scan_rssi.items():
+ filtered_rssi_values = [x for x in val['data'] if not math.isnan(x)]
+ if filtered_rssi_values:
+ scan_rssi[key]['mean'] = statistics.mean(filtered_rssi_values)
+ if len(filtered_rssi_values) > 1:
+ scan_rssi[key]['stdev'] = statistics.stdev(
+ filtered_rssi_values)
+ else:
+ scan_rssi[key]['stdev'] = 0
+ else:
+ scan_rssi[key]['mean'] = RSSI_ERROR_VAL
+ scan_rssi[key]['stdev'] = RSSI_ERROR_VAL
+ return scan_rssi
+
+
+def get_sw_signature(dut):
+ bdf_output = dut.adb.shell('cksum /vendor/firmware/bdwlan*')
+ logging.debug('BDF Checksum output: {}'.format(bdf_output))
+ bdf_signature = sum(
+ [int(line.split(' ')[0]) for line in bdf_output.splitlines()]) % 1000
+
+ fw_output = dut.adb.shell('halutil -logger -get fw')
+ logging.debug('Firmware version output: {}'.format(fw_output))
+ fw_version = re.search(FW_REGEX, fw_output).group('firmware')
+ fw_signature = fw_version.split('.')[-3:-1]
+ fw_signature = float('.'.join(fw_signature))
+ serial_hash = int(hashlib.md5(dut.serial.encode()).hexdigest(), 16) % 1000
+ return {
+ 'config_signature': bdf_signature,
+ 'fw_signature': fw_signature,
+ 'serial_hash': serial_hash
+ }
+
+
+def get_country_code(dut):
+ country_code = dut.adb.shell('iw reg get | grep country | head -1')
+ country_code = country_code.split(':')[0].split(' ')[1]
+ if country_code == '00':
+ country_code = 'WW'
+ return country_code
+
+
+def push_config(dut, config_file):
+ config_files_list = dut.adb.shell(
+ 'ls /vendor/firmware/bdwlan*').splitlines()
+ for dst_file in config_files_list:
+ dut.push_system_file(config_file, dst_file)
+ dut.reboot()
+
+
+def start_wifi_logging(dut):
+ dut.droid.wifiEnableVerboseLogging(1)
+ msg = "Failed to enable WiFi verbose logging."
+ asserts.assert_equal(dut.droid.wifiGetVerboseLoggingLevel(), 1, msg)
+ logging.info('Starting CNSS logs')
+ dut.adb.shell("find /data/vendor/wifi/wlan_logs/ -type f -delete",
+ ignore_status=True)
+ dut.adb.shell_nb('cnss_diag -f -s')
+
+
+def stop_wifi_logging(dut):
+ logging.info('Stopping CNSS logs')
+ dut.adb.shell('killall cnss_diag')
+ logs = dut.get_file_names("/data/vendor/wifi/wlan_logs/")
+ if logs:
+ dut.log.info("Pulling cnss_diag logs %s", logs)
+ log_path = os.path.join(dut.device_log_path,
+ "CNSS_DIAG_%s" % dut.serial)
+ os.makedirs(log_path, exist_ok=True)
+ dut.pull_files(logs, log_path)
+
+
+def push_firmware(dut, firmware_files):
+ """Function to push Wifi firmware files
+
+ Args:
+ dut: dut to push bdf file to
+ firmware_files: path to wlanmdsp.mbn file
+ datamsc_file: path to Data.msc file
+ """
+ for file in firmware_files:
+ dut.push_system_file(file, '/vendor/firmware/')
+ dut.reboot()
+
+
+def _set_ini_fields(ini_file_path, ini_field_dict):
+ template_regex = r'^{}=[0-9,.x-]+'
+ with open(ini_file_path, 'r') as f:
+ ini_lines = f.read().splitlines()
+ for idx, line in enumerate(ini_lines):
+ for field_name, field_value in ini_field_dict.items():
+ line_regex = re.compile(template_regex.format(field_name))
+ if re.match(line_regex, line):
+ ini_lines[idx] = '{}={}'.format(field_name, field_value)
+ print(ini_lines[idx])
+ with open(ini_file_path, 'w') as f:
+ f.write('\n'.join(ini_lines) + '\n')
+
+
+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.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()
+
+
+def set_chain_mask(dut, chain_mask):
+ curr_mask = getattr(dut, 'chain_mask', '2x2')
+ if curr_mask == chain_mask:
+ return
+ dut.chain_mask = chain_mask
+ if chain_mask == '2x2':
+ ini_fields = {
+ 'gEnable2x2': 2,
+ 'gSetTxChainmask1x1': 1,
+ 'gSetRxChainmask1x1': 1,
+ 'gDualMacFeatureDisable': 6,
+ 'gDot11Mode': 0
+ }
+ else:
+ ini_fields = {
+ 'gEnable2x2': 0,
+ 'gSetTxChainmask1x1': chain_mask + 1,
+ 'gSetRxChainmask1x1': chain_mask + 1,
+ 'gDualMacFeatureDisable': 1,
+ 'gDot11Mode': 0
+ }
+ _edit_dut_ini(dut, ini_fields)
+
+
+def set_wifi_mode(dut, mode):
+ TX_MODE_DICT = {
+ 'Auto': 0,
+ '11n': 4,
+ '11ac': 9,
+ '11abg': 1,
+ '11b': 2,
+ '11': 3,
+ '11g only': 5,
+ '11n only': 6,
+ '11b only': 7,
+ '11ac only': 8
+ }
+
+ ini_fields = {
+ 'gEnable2x2': 2,
+ 'gSetTxChainmask1x1': 1,
+ 'gSetRxChainmask1x1': 1,
+ 'gDualMacFeatureDisable': 6,
+ 'gDot11Mode': TX_MODE_DICT[mode]
+ }
+ _edit_dut_ini(dut, ini_fields)
+
+
+class LinkLayerStats():
+
+ LLSTATS_CMD = 'cat /d/wlan0/ll_stats'
+ PEER_REGEX = 'LL_STATS_PEER_ALL'
+ MCS_REGEX = re.compile(
+ r'preamble: (?P<mode>\S+), nss: (?P<num_streams>\S+), bw: (?P<bw>\S+), '
+ 'mcs: (?P<mcs>\S+), bitrate: (?P<rate>\S+), txmpdu: (?P<txmpdu>\S+), '
+ 'rxmpdu: (?P<rxmpdu>\S+), mpdu_lost: (?P<mpdu_lost>\S+), '
+ 'retries: (?P<retries>\S+), retries_short: (?P<retries_short>\S+), '
+ '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}
+
+ def __init__(self, dut, llstats_enabled=True):
+ self.dut = dut
+ self.llstats_enabled = llstats_enabled
+ self.llstats_cumulative = self._empty_llstats()
+ self.llstats_incremental = self._empty_llstats()
+
+ def update_stats(self):
+ if self.llstats_enabled:
+ try:
+ llstats_output = self.dut.adb.shell(self.LLSTATS_CMD,
+ timeout=0.1)
+ except:
+ llstats_output = ''
+ else:
+ llstats_output = ''
+ self._update_stats(llstats_output)
+
+ def reset_stats(self):
+ self.llstats_cumulative = self._empty_llstats()
+ self.llstats_incremental = self._empty_llstats()
+
+ def _empty_llstats(self):
+ return collections.OrderedDict(mcs_stats=collections.OrderedDict(),
+ summary=collections.OrderedDict())
+
+ def _empty_mcs_stat(self):
+ return collections.OrderedDict(txmpdu=0,
+ rxmpdu=0,
+ mpdu_lost=0,
+ retries=0,
+ retries_short=0,
+ retries_long=0)
+
+ def _mcs_id_to_string(self, mcs_id):
+ mcs_string = '{} {}MHz Nss{} MCS{} {}Mbps'.format(
+ mcs_id.mode, mcs_id.bandwidth, mcs_id.num_streams, mcs_id.mcs,
+ mcs_id.rate)
+ return mcs_string
+
+ def _parse_mcs_stats(self, llstats_output):
+ llstats_dict = {}
+ # Look for per-peer stats
+ match = re.search(self.PEER_REGEX, llstats_output)
+ if not match:
+ self.reset_stats()
+ return collections.OrderedDict()
+ # Find and process all matches for per stream stats
+ match_iter = re.finditer(self.MCS_REGEX, llstats_output)
+ for match in match_iter:
+ 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('rate'), 16) / 1000)
+ current_stats = collections.OrderedDict(
+ txmpdu=int(match.group('txmpdu')),
+ rxmpdu=int(match.group('rxmpdu')),
+ mpdu_lost=int(match.group('mpdu_lost')),
+ retries=int(match.group('retries')),
+ retries_short=int(match.group('retries_short')),
+ retries_long=int(match.group('retries_long')))
+ llstats_dict[self._mcs_id_to_string(current_mcs)] = current_stats
+ return llstats_dict
+
+ def _diff_mcs_stats(self, new_stats, old_stats):
+ stats_diff = collections.OrderedDict()
+ for stat_key in new_stats.keys():
+ stats_diff[stat_key] = new_stats[stat_key] - old_stats[stat_key]
+ return stats_diff
+
+ def _generate_stats_summary(self, llstats_dict):
+ llstats_summary = collections.OrderedDict(common_tx_mcs=None,
+ common_tx_mcs_count=0,
+ common_tx_mcs_freq=0,
+ common_rx_mcs=None,
+ common_rx_mcs_count=0,
+ common_rx_mcs_freq=0,
+ rx_per=float('nan'))
+
+ txmpdu_count = 0
+ rxmpdu_count = 0
+ for mcs_id, mcs_stats in llstats_dict['mcs_stats'].items():
+ 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']
+ if mcs_stats['rxmpdu'] > llstats_summary['common_rx_mcs_count']:
+ llstats_summary['common_rx_mcs'] = mcs_id
+ llstats_summary['common_rx_mcs_count'] = mcs_stats['rxmpdu']
+ txmpdu_count += mcs_stats['txmpdu']
+ rxmpdu_count += mcs_stats['rxmpdu']
+ if txmpdu_count:
+ llstats_summary['common_tx_mcs_freq'] = (
+ llstats_summary['common_tx_mcs_count'] / txmpdu_count)
+ if rxmpdu_count:
+ llstats_summary['common_rx_mcs_freq'] = (
+ llstats_summary['common_rx_mcs_count'] / rxmpdu_count)
+ return llstats_summary
+
+ def _update_stats(self, llstats_output):
+ # Parse stats
+ new_llstats = self._empty_llstats()
+ new_llstats['mcs_stats'] = self._parse_mcs_stats(llstats_output)
+ # Save old stats and set new cumulative stats
+ old_llstats = self.llstats_cumulative.copy()
+ self.llstats_cumulative = new_llstats.copy()
+ # Compute difference between new and old stats
+ self.llstats_incremental = self._empty_llstats()
+ for mcs_id, new_mcs_stats in new_llstats['mcs_stats'].items():
+ old_mcs_stats = old_llstats['mcs_stats'].get(
+ mcs_id, self._empty_mcs_stat())
+ self.llstats_incremental['mcs_stats'][
+ mcs_id] = self._diff_mcs_stats(new_mcs_stats, old_mcs_stats)
+ # Generate llstats summary
+ self.llstats_incremental['summary'] = self._generate_stats_summary(
+ self.llstats_incremental)
+ self.llstats_cumulative['summary'] = self._generate_stats_summary(
+ self.llstats_cumulative)
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 b1565d2..5c607ca 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
@@ -20,6 +20,7 @@
from acts.libs.proc import job
from acts.controllers.ap_lib import bridge_interface as bi
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts.controllers.adb_lib.error import AdbCommandError
from acts.controllers.ap_lib import hostapd_security
from acts.controllers.ap_lib import hostapd_ap_preset
@@ -41,8 +42,23 @@
gEnableModulatedDTIM: Modulated DTIM, int
gMaxLIModulatedDTIM: Maximum modulated DTIM, int
"""
- # First trying to find the ini file with DTIM settings
- ini_file_phone = ad.adb.shell('ls /vendor/firmware/wlan/*/*.ini')
+ ad.log.info('Sets dtim to {}'.format(gEnableModulatedDTIM))
+
+ # In P21 the dtim setting method changed and an AdbCommandError will take
+ # place to get ini_file_phone. Thus add try/except block for the old method.
+ # If error occurs, use change_dtim_adb method later. Otherwise, first trying
+ # to find the ini file with DTIM settings
+ try:
+ ini_file_phone = ad.adb.shell('ls /vendor/firmware/wlan/*/*.ini')
+
+ except AdbCommandError as e:
+
+ # Gets AdbCommandError, change dtim later with change_dtim_adb merthod.
+ # change_dtim_adb requires that wifi connection is on.
+ ad.log.info('Gets AdbCommandError, change dtim with change_dtim_adb.')
+ change_dtim_adb(ad, gEnableModulatedDTIM)
+ return 0
+
ini_file_local = ini_file_phone.split('/')[-1]
# Pull the file and change the DTIM to desired value
@@ -81,6 +97,59 @@
ad.log.info('DTIM updated and device back from reboot')
return 1
+def change_dtim_adb(ad, gEnableModulatedDTIM):
+ """Function to change the DTIM setting in the P21 phone.
+
+ This method should be run after connecting wifi.
+
+ Args:
+ ad: the target android device, AndroidDevice object
+ gEnableModulatedDTIM: Modulated DTIM, int
+ """
+ ad.log.info('Changes DTIM to {} with adb'.format(gEnableModulatedDTIM))
+ ad.adb.root()
+ screen_status = ad.adb.shell('dumpsys nfc | grep Screen')
+ screen_is_on = 'ON_UNLOCKED' in screen_status
+
+ # To read the dtim with 'adb shell wl bcn_li_dtim', the screen should be off
+ if screen_is_on:
+ ad.log.info('The screen is on. Set it to off before change dtim')
+ ad.droid.goToSleepNow()
+ time_limit_seconds = 60
+ _wait_screen_off(ad, time_limit_seconds)
+
+ old_dtim = ad.adb.shell('wl bcn_li_dtim')
+ ad.log.info('The dtim before change is {}'.format(old_dtim))
+ if int(old_dtim) == gEnableModulatedDTIM:
+ ad.log.info('Current DTIM is already the desired value,'
+ 'no need to reset it')
+ if screen_is_on:
+ ad.log.info('Changes the screen to the original on status')
+ ad.droid.wakeUpNow()
+ return
+ current_dtim = _set_dtim(ad, gEnableModulatedDTIM)
+ ad.log.info(
+ 'Old DTIM is {}, current DTIM is {}'.format(old_dtim, current_dtim))
+ if screen_is_on:
+ ad.log.info('Changes the screen to the original on status')
+ ad.droid.wakeUpNow()
+
+def _set_dtim(ad, gEnableModulatedDTIM):
+ ad.adb.shell("halutil -dtim_config {}".format(gEnableModulatedDTIM))
+ return ad.adb.shell('wl bcn_li_dtim')
+
+
+def _wait_screen_off(ad, time_limit_seconds):
+ while time_limit_seconds > 0:
+ screen_status = ad.adb.shell('dumpsys nfc | grep Screen')
+ if 'OFF_UNLOCKED' in screen_status:
+ ad.log.info('The screen status is {}'.format(screen_status))
+ return
+ time.sleep(1)
+ time_limit_seconds -= 1
+ raise TimeoutError('Timed out while waiting the screen off after {} '
+ 'seconds.'.format(time_limit_seconds))
+
def push_file_to_phone(ad, file_local, file_phone):
"""Function to push local file to android phone.
@@ -104,7 +173,7 @@
ad.adb.push('{} {}'.format(file_local, file_phone))
-def ap_setup(ap, network, bandwidth=80):
+def ap_setup(ap, network, bandwidth=80, dtim_period=None):
"""Set up the whirlwind AP with provided network info.
Args:
@@ -112,6 +181,7 @@
network: dict with information of the network, including ssid, password
bssid, channel etc.
bandwidth: the operation bandwidth for the AP, default 80MHz
+ dtim_period: the dtim period of access point
Returns:
brconfigs: the bridge interface configs
"""
@@ -128,6 +198,7 @@
config = hostapd_ap_preset.create_ap_preset(
channel=channel,
ssid=ssid,
+ dtim_period=dtim_period,
security=security,
bss_settings=bss_settings,
vht_bandwidth=bandwidth,
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 572a238..16f7a1d 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
@@ -51,8 +51,8 @@
'package': 'netgear_r7500'
},
('Netgear', 'R7500NA'): {
- 'name': 'NetgearR7500NAAP',
- 'package': 'netgear_r7500'
+ 'name': 'NetgearR7500NAAP',
+ 'package': 'netgear_r7500'
},
('Netgear', 'R7800'): {
'name': 'NetgearR7800AP',
@@ -66,13 +66,21 @@
'name': 'NetgearRAX80AP',
'package': 'netgear_rax80'
},
+ ('Netgear', 'RAX120'): {
+ 'name': 'NetgearRAX120AP',
+ 'package': 'netgear_rax120'
+ },
('Netgear', 'RAX200'): {
'name': 'NetgearRAX200AP',
'package': 'netgear_rax200'
},
- ('Netgear', 'RAX120'): {
- 'name': 'NetgearRAX120AP',
- 'package': 'netgear_rax120'
+ ('Netgear', 'RAXE500'): {
+ 'name': 'NetgearRAXE500AP',
+ 'package': 'netgear_raxe500'
+ },
+ ('Brcm', 'Reference'): {
+ 'name': 'BrcmRefAP',
+ 'package': 'brcm_ref'
},
('Google', 'Wifi'): {
'name': 'GoogleWifiAP',
@@ -257,7 +265,8 @@
def teardown(self):
"""Function to perform destroy operations."""
- self._unlock_ap()
+ if self.ap_settings.get('lock_ap', 0):
+ self._unlock_ap()
def reset(self):
"""Function that resets AP.
@@ -316,7 +325,9 @@
Args:
region: string indicating AP region
"""
- self.log.warning('Updating region may overwrite wireless settings.')
+ if region != self.ap_settings['region']:
+ self.log.warning(
+ 'Updating region may overwrite wireless settings.')
setting_to_update = {'region': region}
self.update_ap_settings(setting_to_update)
@@ -350,7 +361,7 @@
if channel not in self.capabilities['channels'][network]:
self.log.error('Ch{} is not supported on {} interface.'.format(
channel, network))
- setting_to_update = {network: {'channel': str(channel)}}
+ setting_to_update = {network: {'channel': channel}}
self.update_ap_settings(setting_to_update)
def set_bandwidth(self, network, bandwidth):
@@ -363,10 +374,39 @@
if 'bw' in bandwidth:
bandwidth = bandwidth.replace('bw',
self.capabilities['default_mode'])
+ elif isinstance(bandwidth, int):
+ bandwidth = str(bandwidth) + self.capabilities['default_mode']
if bandwidth not in self.capabilities['modes'][network]:
self.log.error('{} mode is not supported on {} interface.'.format(
bandwidth, network))
- setting_to_update = {network: {'bandwidth': str(bandwidth)}}
+ setting_to_update = {network: {'bandwidth': bandwidth}}
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel_and_bandwidth(self, network, channel, bandwidth):
+ """Function that sets network bandwidth/mode and channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: string containing desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+ if 'bw' in bandwidth:
+ bandwidth = bandwidth.replace('bw',
+ self.capabilities['default_mode'])
+ elif isinstance(bandwidth, int):
+ bandwidth = str(bandwidth) + self.capabilities['default_mode']
+ if bandwidth not in self.capabilities['modes'][network]:
+ self.log.error('{} mode is not supported on {} interface.'.format(
+ bandwidth, network))
+ if channel not in self.capabilities['channels'][network]:
+ self.log.error('Ch{} is not supported on {} interface.'.format(
+ channel, network))
+ setting_to_update = {
+ network: {
+ 'bandwidth': bandwidth,
+ 'channel': channel
+ }
+ }
self.update_ap_settings(setting_to_update)
def set_power(self, network, power):
@@ -379,7 +419,7 @@
if 'power' not in self.ap_settings[network].keys():
self.log.error(
'Cannot configure power on {} interface.'.format(network))
- setting_to_update = {network: {'power': str(power)}}
+ setting_to_update = {network: {'power': power}}
self.update_ap_settings(setting_to_update)
def set_security(self, network, security_type, *password):
@@ -463,12 +503,13 @@
Args:
channel: channel number to lookup
Returns:
- band: name of band which this channel belongs to on this ap
+ band: name of band which this channel belongs to on this ap, False
+ if not supported
"""
for key, value in self.capabilities['channels'].items():
if channel in value:
return key
- raise ValueError('Invalid channel passed in argument.')
+ return False
def _get_control_ip_address(self):
"""Function to get AP's Control Interface IP address."""
@@ -502,5 +543,9 @@
"""Function to unlock the AP when tests are done."""
self.log.info('Releasing AP lock.')
if hasattr(self, 'lock_file'):
- fcntl.flock(self.lock_file, fcntl.LOCK_UN)
- self.lock_file.close()
+ try:
+ fcntl.flock(self.lock_file, fcntl.LOCK_UN)
+ self.lock_file.close()
+ self.log.info('Succussfully released AP lock file.')
+ except:
+ raise RuntimeError('Error occurred while unlocking AP.')
\ No newline at end of file
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
new file mode 100644
index 0000000..1b09533
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/brcm_ref.py
@@ -0,0 +1,243 @@
+import collections
+import numpy
+import time
+from acts_contrib.test_utils.wifi.wifi_retail_ap import WifiRetailAP
+from acts_contrib.test_utils.wifi.wifi_retail_ap import BlockingBrowser
+
+BROWSER_WAIT_SHORT = 1
+BROWSER_WAIT_MED = 3
+BROWSER_WAIT_LONG = 10
+BROWSER_WAIT_EXTRA_LONG = 60
+
+
+class BrcmRefAP(WifiRetailAP):
+ """Class that implements Netgear RAX200 AP.
+
+ 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()
+ # Read and update AP settings
+ self.read_ap_settings()
+ self.update_ap_settings(ap_settings)
+
+ def init_gui_data(self):
+ self.config_page = ('{protocol}://{username}:{password}@'
+ '{ip_address}:{port}/info.html').format(
+ protocol=self.ap_settings['protocol'],
+ username=self.ap_settings['admin_username'],
+ password=self.ap_settings['admin_password'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+ self.config_page_nologin = (
+ '{protocol}://{ip_address}:{port}/'
+ 'wlrouter/radio.asp').format(
+ protocol=self.ap_settings['protocol'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+
+ self.capabilities = {
+ 'interfaces': ['2G_5G', '6G'],
+ 'channels': {
+ '2G_5G': [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 52, 56,
+ 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136,
+ 140, 144, 149, 153, 157, 161, 165
+ ],
+ '6G': ['6g' + str(ch) for ch in numpy.arange(1, 222, 4)]
+ },
+ 'modes': {
+ '2G_5G': [
+ 'VHT20', 'VHT40', 'VHT80', 'VHT160', 'HE20', 'HE40',
+ 'HE80', 'HE160'
+ ],
+ '6G': [
+ 'VHT20', 'VHT40', 'VHT80', 'VHT160', 'HE20', 'HE40',
+ 'HE80', 'HE160'
+ ]
+ },
+ 'default_mode': 'HE'
+ }
+ self.ap_settings['region'] = 'United States'
+ for interface in self.capabilities['interfaces']:
+ self.ap_settings[interface] = {
+ 'ssid': 'BrcmAP0' if interface == '6G' else 'BrcmAP1',
+ 'security_type': 'Open',
+ 'password': '1234567890'
+ }
+ self.config_page_fields = collections.OrderedDict({
+ ('2G_5G', 'interface'): ('wl_unit', 1),
+ ('2G_5G', 'band'):
+ 'wl_nband',
+ ('2G_5G', 'bandwidth'):
+ 'wl_bw_cap',
+ ('2G_5G', 'channel'):
+ 'wl_chanspec',
+ ('6G', 'interface'): ('wl_unit', 0),
+ ('6G', 'band'):
+ 'wl_nband',
+ ('6G', 'bandwidth'):
+ 'wl_bw_cap',
+ ('6G', 'channel'):
+ 'wl_chanspec',
+ })
+
+ self.band_mode_values = {'1': '5 GHz', '2': '2.4 GHz', '4': '6 GHz'}
+
+ self.band_values = {'5 GHz': 1, '2.4 GHz': 2, '6 GHz': 4}
+
+ self.bandwidth_mode_values = {
+ '1': 'HE20',
+ '3': 'HE40',
+ '7': 'HE80',
+ '15': 'HE160'
+ }
+
+ def _decode_channel_string(self, channel_string):
+ if channel_string == '0':
+ return 'Auto'
+ if 'u' in channel_string or 'l' in channel_string:
+ channel_string = channel_string[0:-1]
+ elif len(channel_string.split('/')) > 1:
+ channel_string = channel_string.split('/')[0]
+ if '6g' in channel_string:
+ return channel_string
+ else:
+ return int(channel_string)
+
+ def _get_channel_str(self, interface, channel, bandwidth):
+ bandwidth = int(''.join([x for x in bandwidth if x.isdigit()]))
+ if bandwidth == 20:
+ channel_str = str(channel)
+ elif bandwidth in [80, 160]:
+ channel_str = str(channel) + '/' + str(bandwidth)
+ elif interface == '6G' and bandwidth == 40:
+ channel_str = str(channel) + '/' + str(bandwidth)
+ elif interface == '2G_5G' and bandwidth == 40:
+ lower_lookup = [
+ 36, 44, 52, 60, 100, 108, 116, 124, 132, 140, 149, 157
+ ]
+ if int(channel) in lower_lookup:
+ channel_str = str(channel) + 'l'
+ else:
+ channel_str = str(channel) + 'u'
+ return channel_str
+
+ def read_ap_settings(self):
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+ # Visit URL
+ browser.visit_persistent(self.config_page, BROWSER_WAIT_MED, 10)
+ browser.visit_persistent(self.config_page_nologin,
+ BROWSER_WAIT_MED, 10, self.config_page)
+
+ for key in self.config_page_fields.keys():
+ if 'interface' in key:
+ config_item = browser.find_by_name(
+ self.config_page_fields[key][0]).first
+ config_item.select(self.config_page_fields[key][1])
+ time.sleep(BROWSER_WAIT_SHORT)
+ else:
+ config_item = browser.find_by_name(
+ self.config_page_fields[key]).first
+ if 'band' in key:
+ self.ap_settings[key[0]][
+ key[1]] = self.band_mode_values[config_item.value]
+ elif 'bandwidth' in key:
+ self.ap_settings[key[0]][key[
+ 1]] = self.bandwidth_mode_values[config_item.value]
+ elif 'channel' in key:
+ self.ap_settings[key[0]][
+ key[1]] = self._decode_channel_string(
+ config_item.value)
+ else:
+ self.ap_settings[key[0]][key[1]] = config_item.value
+
+ def update_ap_settings(self, dict_settings={}, **named_settings):
+ """Function to update settings of existing AP.
+
+ Function copies arguments into ap_settings and calls configure_ap
+ to apply them.
+
+ Args:
+ dict_settings: single dictionary of settings to update
+ **named_settings: named settings to update
+ Note: dict and named_settings cannot contain the same settings.
+ """
+
+ settings_to_update = dict(dict_settings, **named_settings)
+ if len(settings_to_update) != len(dict_settings) + len(named_settings):
+ raise KeyError('The following keys were passed twice: {}'.format(
+ (set(dict_settings.keys()).intersection(
+ set(named_settings.keys())))))
+
+ updating_6G = '6G' in settings_to_update.keys()
+ updating_2G_5G = '2G_5G' in settings_to_update.keys()
+
+ if updating_2G_5G:
+ if 'channel' in settings_to_update['2G_5G']:
+ band = '2.4 GHz' if int(
+ settings_to_update['2G_5G']['channel']) < 13 else '5 GHz'
+ if band == '2.4 GHz':
+ settings_to_update['2G_5G']['bandwidth'] = 'HE20'
+ settings_to_update['2G_5G']['band'] = band
+ self.ap_settings, updates_requested, status_toggle_flag = self._update_settings_dict(
+ self.ap_settings, settings_to_update)
+ if updates_requested:
+ self.configure_ap(updating_2G_5G, updating_6G)
+
+ def configure_ap(self, updating_2G_5G, updating_6G):
+
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+
+ interfaces_to_update = []
+ if updating_2G_5G:
+ interfaces_to_update.append('2G_5G')
+ if updating_6G:
+ interfaces_to_update.append('6G')
+ for interface in interfaces_to_update:
+ # Visit URL
+ browser.visit_persistent(self.config_page, BROWSER_WAIT_MED,
+ 10)
+ browser.visit_persistent(self.config_page_nologin,
+ BROWSER_WAIT_MED, 10,
+ self.config_page)
+
+ config_item = browser.find_by_name(
+ self.config_page_fields[(interface, 'interface')][0]).first
+ config_item.select(self.config_page_fields[(interface,
+ 'interface')][1])
+ time.sleep(BROWSER_WAIT_SHORT)
+
+ for key, value in self.config_page_fields.items():
+ if 'interface' in key or interface not in key:
+ continue
+ config_item = browser.find_by_name(
+ self.config_page_fields[key]).first
+ if 'band' in key:
+ config_item.select(
+ self.band_values[self.ap_settings[key[0]][key[1]]])
+ elif 'bandwidth' in key:
+ config_item.select_by_text(
+ str(self.ap_settings[key[0]][key[1]])[2:] + ' MHz')
+ elif 'channel' in key:
+ channel_str = self._get_channel_str(
+ interface, self.ap_settings[interface][key[1]],
+ self.ap_settings[interface]['bandwidth'])
+ config_item.select_by_text(channel_str)
+ else:
+ self.ap_settings[key[0]][key[1]] = config_item.value
+ time.sleep(BROWSER_WAIT_SHORT)
+ # Apply
+ config_item = browser.find_by_name('action')
+ config_item.first.click()
+ time.sleep(BROWSER_WAIT_MED)
+ config_item = browser.find_by_name('action')
+ time.sleep(BROWSER_WAIT_SHORT)
+ config_item.first.click()
+ time.sleep(BROWSER_WAIT_LONG)
+ browser.visit_persistent(self.config_page, BROWSER_WAIT_LONG,
+ 10)
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 dd4ee9f..4023b9a 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
@@ -93,6 +93,14 @@
'subnet': '192.168.9.0/24'
}
}
+ for setting in self.default_settings.keys():
+ if setting in self.capabilities['interfaces']:
+ continue
+ elif setting not in self.ap_settings:
+ self.log.debug(
+ '{0} {1} not found during init. Setting {0} = {1}'.format(
+ setting, self.default_settings[setting]))
+ self.ap_settings[setting] = self.default_settings[setting]
for interface in self.capabilities['interfaces']:
for setting in self.default_settings[interface].keys():
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 e7f4e83..ac118df 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
@@ -278,5 +278,5 @@
"""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()
+ super().init_gui_data()
self.region_map['11'] = 'North America'
diff --git a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax120.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax120.py
index e718ebd..d1420df 100644
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax120.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_rax120.py
@@ -108,6 +108,12 @@
'19': 'Russia',
'20': 'Singapore',
'21': 'Taiwan',
+ 'Australia': 'Australia',
+ 'Europe': 'Europe',
+ 'Korea': 'Korea',
+ 'Singapore': 'Singapore',
+ 'Hong Kong': 'Hong Kong',
+ 'United States': 'United States',
}
self.bw_mode_text = {
'2G': {
@@ -120,12 +126,12 @@
'5G_1': {
'HE20': 'Up to 1147 Mbps (11ax, HT20, 1024-QAM)',
'HE40': 'Up to 2294 Mbps (11ax, HT40, 1024-QAM)',
- 'HE80': 'Up to 4803 Mbps (11ax, HT80, 1024-QAM)',
- 'HE160': 'Up to 4803 Mbps (11ax, HT160, 1024-QAM)',
+ 'HE80': 'Up to 4803 Mbps (80MHz) (11ax, HT80, 1024-QAM)',
+ 'HE160': 'Up to 4803 Mbps (160MHz) (11ax, HT160, 1024-QAM)',
'VHT20': 'Up to 962 Mbps (11ac, HT20, 1024-QAM)',
'VHT40': 'Up to 2000 Mbps (11ac, HT40, 1024-QAM)',
- 'VHT80': 'Up to 4333 Mbps (11ac, HT80, 1024-QAM)',
- 'VHT160': 'Up to 4333 Mbps (11ac, HT160, 1024-QAM)'
+ 'VHT80': 'Up to 4333 Mbps (80MHz) (11ac, HT80, 1024-QAM)',
+ 'VHT160': 'Up to 4333 Mbps (160MHz) (11ac, HT160, 1024-QAM)'
}
}
self.bw_mode_values = {
@@ -146,7 +152,14 @@
'7': 'HE20',
'8': 'HE40',
'9': 'HE80',
- '10': 'HE160'
+ '10': 'HE160',
+ '54': '11g',
+ '573.5': 'HE20',
+ '1146': 'HE40',
+ '1147': 'HE20',
+ '2294': 'HE40',
+ '4803-HT80': 'HE80',
+ '4803-HT160': 'HE160'
}
}
self.security_mode_values = {
@@ -160,6 +173,55 @@
}
}
+ def _set_channel_and_bandwidth(self,
+ network,
+ channel=None,
+ bandwidth=None):
+ """Helper function that sets network bandwidth and channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+ setting_to_update = {network: {}}
+ if channel:
+ if channel not in self.capabilities['channels'][network]:
+ self.log.error('Ch{} is not supported on {} interface.'.format(
+ channel, network))
+ setting_to_update[network]['channel'] = channel
+
+ if bandwidth is None:
+ return setting_to_update
+
+ if 'bw' in bandwidth:
+ bandwidth = bandwidth.replace('bw',
+ self.capabilities['default_mode'])
+ if bandwidth not in self.capabilities['modes'][network]:
+ self.log.error('{} mode is not supported on {} interface.'.format(
+ bandwidth, network))
+ setting_to_update[network]['bandwidth'] = str(bandwidth)
+ setting_to_update['enable_ax'] = int('HE' in bandwidth)
+ # Check if other interfaces need to be changed too
+ requested_mode = 'HE' if 'HE' in bandwidth else 'VHT'
+ for other_network in self.capabilities['interfaces']:
+ if other_network == network:
+ continue
+ other_mode = 'HE' if 'HE' in self.ap_settings[other_network][
+ 'bandwidth'] else 'VHT'
+ other_bw = ''.join([
+ x for x in self.ap_settings[other_network]['bandwidth']
+ if x.isdigit()
+ ])
+ if other_mode != requested_mode:
+ updated_mode = '{}{}'.format(requested_mode, other_bw)
+ self.log.warning('All networks must be VHT or HE. '
+ 'Updating {} to {}'.format(
+ other_network, updated_mode))
+ setting_to_update.setdefault(other_network, {})
+ setting_to_update[other_network]['bandwidth'] = updated_mode
+ return setting_to_update
+
def set_bandwidth(self, network, bandwidth):
"""Function that sets network bandwidth/mode.
@@ -167,31 +229,31 @@
network: string containing network identifier (2G, 5G_1, 5G_2)
bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
"""
- if 'bw' in bandwidth:
- bandwidth = bandwidth.replace('bw',
- self.capabilities['default_mode'])
- if bandwidth not in self.capabilities['modes'][network]:
- self.log.error('{} mode is not supported on {} interface.'.format(
- bandwidth, network))
- setting_to_update = {network: {'bandwidth': str(bandwidth)}}
- setting_to_update['enable_ax'] = int('HE' in bandwidth)
- # Check if other interfaces need to be changed too
- requested_mode = 'HE' if 'HE' in bandwidth else 'VHT'
- other_network = '2G' if '5G_1' in network else '5G_1'
- other_mode = 'HE' if 'HE' in self.ap_settings[other_network][
- 'bandwidth'] else 'VHT'
- other_bw = ''.join([
- x for x in self.ap_settings[other_network]['bandwidth']
- if x.isdigit()
- ])
- if other_mode != requested_mode:
- updated_mode = '{}{}'.format(requested_mode, other_bw)
- self.log.warning('All networks must be VHT or HE. '
- 'Updating {} to {}'.format(
- other_network, updated_mode))
- setting_to_update.setdefault(other_network, {})
- setting_to_update[other_network]['bandwidth'] = updated_mode
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, bandwidth=bandwidth)
+ self.update_ap_settings(setting_to_update)
+ def set_channel(self, network, channel):
+ """Function that sets network channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: string or int containing channel
+ """
+ setting_to_update = self._set_channel_and_bandwidth(network,
+ channel=channel)
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel_and_bandwidth(self, network, channel, bandwidth):
+ """Function that sets network bandwidth/mode.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, channel=channel, bandwidth=bandwidth)
self.update_ap_settings(setting_to_update)
def read_ap_settings(self):
@@ -236,9 +298,13 @@
key[1]] = 'defaultpassword'
self.ap_settings[
key[0]]['security_type'] = 'Disable'
- elif ('channel' in key) or ('ssid' in key):
+ elif ('ssid' in key):
config_item = iframe.find_by_name(value).first
self.ap_settings[key[0]][key[1]] = config_item.value
+ elif ('channel' in key):
+ config_item = iframe.find_by_name(value).first
+ self.ap_settings[key[0]][key[1]] = int(
+ config_item.value)
return self.ap_settings.copy()
def configure_ap(self, **config_flags):
@@ -269,9 +335,13 @@
'enable_ax_chec')
action.move_to_element(ax_checkbox).click().perform()
# Update AP region. Must be done before channel setting
- config_item = iframe.find_by_name(
- self.config_page_fields['region']).first
- config_item.select_by_text(self.ap_settings['region'])
+ try:
+ config_item = iframe.find_by_name(
+ self.config_page_fields['region']).first
+ config_item.select_by_text(self.ap_settings['region'])
+ except:
+ self.log.warning('Could not set AP region to {}.'.format(
+ self.ap_settings['region']))
# Update wireless settings for each network
for key, value in self.config_page_fields.items():
if 'ssid' in key:
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 91c6382..d6c6fad 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
@@ -15,7 +15,6 @@
# limitations under the License.
import collections
-import selenium
import time
from acts_contrib.test_utils.wifi.wifi_retail_ap import WifiRetailAP
from acts_contrib.test_utils.wifi.wifi_retail_ap import BlockingBrowser
@@ -119,7 +118,7 @@
'VHT20': 'Up to 433 Mbps',
'VHT40': 'Up to 1000 Mbps',
'VHT80': 'Up to 2165 Mbps',
- 'VHT160': 'Up to 4330'
+ 'VHT160': 'Up to 4330 Mbps'
},
'5G_2': {
'HE20': 'Up to 600 Mbps',
@@ -129,7 +128,7 @@
'VHT20': 'Up to 433 Mbps',
'VHT40': 'Up to 1000 Mbps',
'VHT80': 'Up to 2165 Mbps',
- 'VHT160': 'Up to 4330'
+ 'VHT160': 'Up to 4330 Mbps'
}
}
self.bw_mode_values = {
@@ -181,20 +180,34 @@
'4': '25%'
}
- def set_bandwidth(self, network, bandwidth):
- """Function that sets network bandwidth/mode.
+ def _set_channel_and_bandwidth(self,
+ network,
+ channel=None,
+ bandwidth=None):
+ """Helper function that sets network bandwidth and channel.
Args:
network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
"""
+ setting_to_update = {network: {}}
+ if channel:
+ if channel not in self.capabilities['channels'][network]:
+ self.log.error('Ch{} is not supported on {} interface.'.format(
+ channel, network))
+ setting_to_update[network]['channel'] = channel
+
+ if bandwidth is None:
+ return setting_to_update
+
if 'bw' in bandwidth:
bandwidth = bandwidth.replace('bw',
self.capabilities['default_mode'])
if bandwidth not in self.capabilities['modes'][network]:
self.log.error('{} mode is not supported on {} interface.'.format(
bandwidth, network))
- setting_to_update = {network: {'bandwidth': str(bandwidth)}}
+ setting_to_update[network]['bandwidth'] = str(bandwidth)
setting_to_update['enable_ax'] = int('HE' in bandwidth)
# Check if other interfaces need to be changed too
requested_mode = 'HE' if 'HE' in bandwidth else 'VHT'
@@ -214,7 +227,41 @@
other_network, updated_mode))
setting_to_update.setdefault(other_network, {})
setting_to_update[other_network]['bandwidth'] = updated_mode
+ return setting_to_update
+ def set_bandwidth(self, network, bandwidth):
+ """Function that sets network bandwidth/mode.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, bandwidth=bandwidth)
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel(self, network, channel):
+ """Function that sets network channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: string or int containing channel
+ """
+ setting_to_update = self._set_channel_and_bandwidth(network,
+ channel=channel)
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel_and_bandwidth(self, network, channel, bandwidth):
+ """Function that sets network bandwidth/mode.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, channel=channel, bandwidth=bandwidth)
self.update_ap_settings(setting_to_update)
def read_ap_settings(self):
@@ -252,6 +299,10 @@
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)
else:
config_item = browser.find_by_name(value)
self.ap_settings[key[0]][
@@ -321,8 +372,10 @@
self.log.warning(
'Cannot select channel. Keeping AP default.')
try:
- alert = browser.get_alert()
- alert.accept()
+ for idx in range(0, 2):
+ alert = browser.get_alert()
+ alert.accept()
+ time.sleep(BROWSER_WAIT_SHORT)
except:
pass
time.sleep(BROWSER_WAIT_SHORT)
@@ -336,7 +389,6 @@
time.sleep(BROWSER_WAIT_SHORT)
browser.visit_persistent(self.config_page, BROWSER_WAIT_EXTRA_LONG,
10)
- self.validate_ap_settings()
def configure_radio_on_off(self):
"""Helper configuration function to turn radios on/off."""
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
new file mode 100644
index 0000000..9dc60aa
--- /dev/null
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_retail_ap/netgear_raxe500.py
@@ -0,0 +1,442 @@
+#!/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 collections
+import numpy
+import re
+import time
+from acts_contrib.test_utils.wifi.wifi_retail_ap import WifiRetailAP
+from acts_contrib.test_utils.wifi.wifi_retail_ap import BlockingBrowser
+
+BROWSER_WAIT_SHORT = 1
+BROWSER_WAIT_MED = 3
+BROWSER_WAIT_LONG = 30
+BROWSER_WAIT_EXTRA_LONG = 60
+
+
+class NetgearRAXE500AP(WifiRetailAP):
+ """Class that implements Netgear RAXE500 AP.
+
+ 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()
+ # Read and update AP settings
+ self.read_ap_firmware()
+ self.read_ap_settings()
+ self.update_ap_settings(ap_settings)
+
+ def init_gui_data(self):
+ self.config_page = (
+ '{protocol}://{username}:{password}@'
+ '{ip_address}:{port}/WLG_wireless_tri_band.htm').format(
+ protocol=self.ap_settings['protocol'],
+ username=self.ap_settings['admin_username'],
+ password=self.ap_settings['admin_password'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+ self.config_page_nologin = (
+ '{protocol}://{ip_address}:{port}/'
+ 'WLG_wireless_tri_band.htm').format(
+ protocol=self.ap_settings['protocol'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+ self.config_page_advanced = (
+ '{protocol}://{username}:{password}@'
+ '{ip_address}:{port}/WLG_adv_tri_band2.htm').format(
+ protocol=self.ap_settings['protocol'],
+ username=self.ap_settings['admin_username'],
+ password=self.ap_settings['admin_password'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+ self.firmware_page = (
+ '{protocol}://{username}:{password}@'
+ '{ip_address}:{port}/ADVANCED_home2_tri_band.htm').format(
+ protocol=self.ap_settings['protocol'],
+ username=self.ap_settings['admin_username'],
+ password=self.ap_settings['admin_password'],
+ ip_address=self.ap_settings['ip_address'],
+ port=self.ap_settings['port'])
+ self.capabilities = {
+ 'interfaces': ['2G', '5G_1', '6G'],
+ 'channels': {
+ '2G': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+ '5G_1': [
+ 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116,
+ 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165
+ ],
+ '6G': ['6g' + str(ch) for ch in numpy.arange(37, 222, 16)]
+ },
+ 'modes': {
+ '2G': ['VHT20', 'VHT40', 'HE20', 'HE40'],
+ '5G_1': [
+ 'VHT20', 'VHT40', 'VHT80', 'VHT160', 'HE20', 'HE40',
+ 'HE80', 'HE160'
+ ],
+ '6G': [
+ 'VHT20', 'VHT40', 'VHT80', 'VHT160', 'HE20', 'HE40',
+ 'HE80', 'HE160'
+ ]
+ },
+ 'default_mode': 'HE'
+ }
+ for interface in self.capabilities['interfaces']:
+ self.ap_settings[interface] = {}
+
+ self.region_map = {
+ '3': 'Australia',
+ '4': 'Canada',
+ '5': 'Europe',
+ '7': 'Japan',
+ '8': 'Korea',
+ '11': 'North America',
+ '16': 'China',
+ '17': 'India',
+ '21': 'Middle East(Saudi Arabia/United Arab Emirates)',
+ '23': 'Singapore',
+ '25': 'Hong Kong',
+ '26': 'Vietnam'
+ }
+
+ self.bw_mode_text = {
+ '2G': {
+ 'g and b': 'Up to 54 Mbps',
+ 'HE20': 'Up to 600 Mbps',
+ 'HE40': 'Up to 1200 Mbps',
+ 'VHT20': 'Up to 433 Mbps',
+ 'VHT40': 'Up to 1000 Mbps'
+ },
+ '5G_1': {
+ 'HE20': 'Up to 600 Mbps',
+ 'HE40': 'Up to 1200 Mbps',
+ 'HE80': 'Up to 2400 Mbps',
+ 'HE160': 'Up to 4800 Mbps',
+ 'VHT20': 'Up to 433 Mbps',
+ 'VHT40': 'Up to 1000 Mbps',
+ 'VHT80': 'Up to 2165 Mbps',
+ 'VHT160': 'Up to 4330 Mbps'
+ },
+ '6G': {
+ 'HE20': 'Up to 600 Mbps',
+ 'HE40': 'Up to 1200 Mbps',
+ 'HE80': 'Up to 2400 Mbps',
+ 'HE160': 'Up to 4800 Mbps',
+ 'VHT20': 'Up to 600 Mbps',
+ 'VHT40': 'Up to 1200 Mbps',
+ 'VHT80': 'Up to 2400 Mbps',
+ 'VHT160': 'Up to 4800 Mbps'
+ }
+ }
+ self.bw_mode_values = {
+ # first key is a boolean indicating if 11ax is enabled
+ 0: {
+ 'g and b': '11g',
+ 'HT20': 'VHT20',
+ 'HT40': 'VHT40',
+ 'HT80': 'VHT80',
+ 'HT160': 'VHT160'
+ },
+ 1: {
+ 'g and b': '11g',
+ 'HT20': 'HE20',
+ 'HT40': 'HE40',
+ 'HT80': 'HE80',
+ 'HT160': 'HE160'
+ }
+ }
+
+ # Config ordering intentional to avoid GUI bugs
+ self.config_page_fields = collections.OrderedDict([
+ ('region', 'WRegion'), ('enable_ax', 'enable_he'),
+ (('2G', 'status'), 'enable_ap'),
+ (('5G_1', 'status'), 'enable_ap_an'),
+ (('6G', 'status'), 'enable_ap_an_2'), (('2G', 'ssid'), 'ssid'),
+ (('5G_1', 'ssid'), 'ssid_an'), (('6G', 'ssid'), 'ssid_an_2'),
+ (('2G', 'channel'), 'w_channel'),
+ (('5G_1', 'channel'), 'w_channel_an'),
+ (('6G', 'channel'), 'w_channel_an_2'),
+ (('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'),
+ (('2G', 'password'), 'passphrase'),
+ (('5G_1', 'password'), 'passphrase_an'),
+ (('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,
+ bandwidth=None):
+ """Helper function that sets network bandwidth and channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+
+ setting_to_update = {network: {}}
+ if channel:
+ if channel not in self.capabilities['channels'][network]:
+ self.log.error('Ch{} is not supported on {} interface.'.format(
+ channel, network))
+ if isinstance(channel, str) and '6g' in channel:
+ channel = int(channel[2:])
+ setting_to_update[network]['channel'] = channel
+
+ if bandwidth is None:
+ return setting_to_update
+
+ if 'bw' in bandwidth:
+ bandwidth = bandwidth.replace('bw',
+ self.capabilities['default_mode'])
+ if bandwidth not in self.capabilities['modes'][network]:
+ self.log.error('{} mode is not supported on {} interface.'.format(
+ bandwidth, network))
+ setting_to_update[network]['bandwidth'] = str(bandwidth)
+ setting_to_update['enable_ax'] = int('HE' in bandwidth)
+ # Check if other interfaces need to be changed too
+ requested_mode = 'HE' if 'HE' in bandwidth else 'VHT'
+ for other_network in self.capabilities['interfaces']:
+ if other_network == network:
+ continue
+ other_mode = 'HE' if 'HE' in self.ap_settings[other_network][
+ 'bandwidth'] else 'VHT'
+ other_bw = ''.join([
+ x for x in self.ap_settings[other_network]['bandwidth']
+ if x.isdigit()
+ ])
+ if other_mode != requested_mode:
+ updated_mode = '{}{}'.format(requested_mode, other_bw)
+ self.log.warning('All networks must be VHT or HE. '
+ 'Updating {} to {}'.format(
+ other_network, updated_mode))
+ setting_to_update.setdefault(other_network, {})
+ setting_to_update[other_network]['bandwidth'] = updated_mode
+ return setting_to_update
+
+ def set_bandwidth(self, network, bandwidth):
+ """Function that sets network bandwidth/mode.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, bandwidth=bandwidth)
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel(self, network, channel):
+ """Function that sets network channel.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: string or int containing channel
+ """
+ setting_to_update = self._set_channel_and_bandwidth(network,
+ channel=channel)
+ self.update_ap_settings(setting_to_update)
+
+ def set_channel_and_bandwidth(self, network, channel, bandwidth):
+ """Function that sets network bandwidth/mode.
+
+ Args:
+ network: string containing network identifier (2G, 5G_1, 5G_2)
+ channel: desired channel
+ bandwidth: string containing mode, e.g. 11g, VHT20, VHT40, VHT80.
+ """
+ setting_to_update = self._set_channel_and_bandwidth(
+ network, channel=channel, bandwidth=bandwidth)
+ self.update_ap_settings(setting_to_update)
+
+ def read_ap_firmware(self):
+ """Function to read ap settings."""
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+
+ # Visit URL
+ 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)
+ if firmware_version:
+ self.ap_settings['firmware_version'] = firmware_version.group(
+ 'version')
+ else:
+ self.ap_settings['firmware_version'] = -1
+
+ def read_ap_settings(self):
+ """Function to read ap settings."""
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+ # 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:
+ 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)
+ 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:
+ 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)
+ else:
+ config_item = browser.find_by_name(value)
+ self.ap_settings[key[0]][
+ key[1]] = config_item.first.value
+ return self.ap_settings.copy()
+
+ def configure_ap(self, **config_flags):
+ """Function to configure ap wireless settings."""
+ # Turn radios on or off
+ if config_flags['status_toggled']:
+ self.configure_radio_on_off()
+ # Configure radios
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+ # Visit URL
+ browser.visit_persistent(self.config_page, BROWSER_WAIT_MED, 10)
+ browser.visit_persistent(self.config_page_nologin,
+ 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:
+ 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
+ try:
+ config_item.select_by_text(self.bw_mode_text[key[0]][
+ self.ap_settings[key[0]][key[1]]])
+ 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 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
+ try:
+ config_item.select(self.ap_settings[key[0]][key[1]])
+ time.sleep(BROWSER_WAIT_SHORT)
+ except AttributeError:
+ self.log.warning(
+ 'Cannot select channel. Keeping AP default.')
+ try:
+ alert = browser.get_alert()
+ alert.accept()
+ except:
+ pass
+ time.sleep(BROWSER_WAIT_SHORT)
+ browser.find_by_name('Apply').first.click()
+ 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)
+
+ def configure_radio_on_off(self):
+ """Helper configuration function to turn radios on/off."""
+ with BlockingBrowser(self.ap_settings['headless_browser'],
+ 900) as browser:
+ # Visit URL
+ browser.visit_persistent(self.config_page, BROWSER_WAIT_MED, 10)
+ browser.visit_persistent(self.config_page_advanced,
+ 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()
+
+ time.sleep(BROWSER_WAIT_SHORT)
+ browser.find_by_name('Apply').first.click()
+ 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_test_utils.py b/acts_tests/acts_contrib/test_utils/wifi/wifi_test_utils.py
index 1729a7c..c29ce5c 100755
--- a/acts_tests/acts_contrib/test_utils/wifi/wifi_test_utils.py
+++ b/acts_tests/acts_contrib/test_utils/wifi/wifi_test_utils.py
@@ -439,6 +439,14 @@
165: 5825
}
+ channel_6G_to_freq = {4 * x + 1: 5955 + 20 * x for x in range(59)}
+
+ channel_to_freq = {
+ '2G': channel_2G_to_freq,
+ '5G': channel_5G_to_freq,
+ '6G': channel_6G_to_freq
+ }
+
class WifiChannelBase:
ALL_2G_FREQUENCIES = []
@@ -1713,7 +1721,8 @@
# Need a delay here because UI interaction should only start once wifi
# starts processing the request.
time.sleep(wifi_constants.NETWORK_REQUEST_CB_REGISTER_DELAY_SEC)
- _wait_for_wifi_connect_after_network_request(ad, network, key, num_of_tries)
+ _wait_for_wifi_connect_after_network_request(ad, network, key,
+ num_of_tries)
return key
@@ -1749,7 +1758,10 @@
assert_on_fail, ad, network, key, num_of_tries)
-def _wait_for_wifi_connect_after_network_request(ad, network, key, num_of_tries=3):
+def _wait_for_wifi_connect_after_network_request(ad,
+ network,
+ key,
+ num_of_tries=3):
"""
Simulate and verify the connection flow after initiating the network
request.
@@ -1801,13 +1813,11 @@
# Wait for the platform to connect to the network.
autils.wait_for_event_with_keys(
- ad, cconsts.EVENT_NETWORK_CALLBACK,
- 60,
+ ad, cconsts.EVENT_NETWORK_CALLBACK, 60,
(cconsts.NETWORK_CB_KEY_ID, key),
(cconsts.NETWORK_CB_KEY_EVENT, cconsts.NETWORK_CB_AVAILABLE))
on_capabilities_changed = autils.wait_for_event_with_keys(
- ad, cconsts.EVENT_NETWORK_CALLBACK,
- 10,
+ ad, cconsts.EVENT_NETWORK_CALLBACK, 10,
(cconsts.NETWORK_CB_KEY_ID, key),
(cconsts.NETWORK_CB_KEY_EVENT,
cconsts.NETWORK_CB_CAPABILITIES_CHANGED))
@@ -1824,8 +1834,7 @@
asserts.assert_equal(
connected_network[WifiEnums.SSID_KEY], expected_ssid,
"Connected to the wrong network."
- "Expected %s, but got %s."
- % (network, connected_network))
+ "Expected %s, but got %s." % (network, connected_network))
except Empty:
asserts.fail("Failed to connect to %s" % expected_ssid)
except Exception as error:
diff --git a/acts_tests/setup.py b/acts_tests/setup.py
index 6c0a4a6..b2c3151 100755
--- a/acts_tests/setup.py
+++ b/acts_tests/setup.py
@@ -45,7 +45,6 @@
# Python 3.8+ is support by latest bokeh
install_requires.append('bokeh')
-
def _setup_acts_framework(option, *args):
"""Locates and runs setup.py for the ACTS framework.
diff --git a/acts_tests/tests/google/ble/performance/BleRangeTest.py b/acts_tests/tests/google/ble/performance/BleRangeTest.py
new file mode 100644
index 0000000..3473cef
--- /dev/null
+++ b/acts_tests/tests/google/ble/performance/BleRangeTest.py
@@ -0,0 +1,289 @@
+#!/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.
+"""
+Test script to execute BLE connection,run data traffic and calculating RSSI value of the remote BLE device.
+"""
+
+import os
+import logging
+import pandas as pd
+import numpy as np
+import time
+import acts_contrib.test_utils.bt.bt_test_utils as btutils
+import acts_contrib.test_utils.wifi.wifi_performance_test_utils.bokeh_figure as bokeh_figure
+from acts_contrib.test_utils.bt.ble_performance_test_utils import ble_coc_connection
+from acts_contrib.test_utils.bt.ble_performance_test_utils import ble_gatt_disconnection
+from acts_contrib.test_utils.bt.ble_performance_test_utils import start_advertising_and_scanning
+from acts_contrib.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest
+from acts_contrib.test_utils.bt.bt_test_utils import cleanup_scanners_and_advertisers
+from acts_contrib.test_utils.bt.ble_performance_test_utils import establish_ble_connection
+from acts_contrib.test_utils.bt.bt_constants import l2cap_max_inactivity_delay_after_disconnect
+from acts_contrib.test_utils.bt.ble_performance_test_utils import run_ble_throughput
+from acts_contrib.test_utils.bt.ble_performance_test_utils import read_ble_rssi
+from acts_contrib.test_utils.bt.ble_performance_test_utils import read_ble_scan_rssi
+from acts_contrib.test_utils.bt.bt_test_utils import reset_bluetooth
+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.signals import TestPass
+from acts import utils
+
+INIT_ATTEN = 0
+MAX_RSSI = 92
+
+
+class BleRangeTest(BluetoothBaseTest):
+ active_adv_callback_list = []
+ active_scan_callback_list = []
+
+ 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.client_ad = self.android_devices[0]
+ # The client which is scanning will need location to be enabled in order to
+ # start scan and get scan results.
+ utils.set_location_service(self.client_ad, True)
+ self.server_ad = self.android_devices[1]
+ # Note that some tests required a third device.
+ 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)
+ # BokehFigure object
+ self.plot = bokeh_figure.BokehFigure(
+ title='{}'.format(self.current_test_name),
+ x_label='Pathloss (dB)',
+ primary_y_label='BLE RSSI (dBm)',
+ secondary_y_label='DUT Tx Power (dBm)',
+ axis_label_size='16pt')
+ if len(self.android_devices) > 2:
+ self.server2_ad = self.android_devices[2]
+
+ btutils.enable_bqr(self.android_devices)
+ return setup_multiple_devices_for_bt_test(self.android_devices)
+
+ def teardown_test(self):
+ self.client_ad.droid.bluetoothSocketConnStop()
+ self.server_ad.droid.bluetoothSocketConnStop()
+ if hasattr(self, 'attenuator'):
+ self.attenuator.set_atten(INIT_ATTEN)
+ # Give sufficient time for the physical LE link to be disconnected.
+ time.sleep(l2cap_max_inactivity_delay_after_disconnect)
+ cleanup_scanners_and_advertisers(self.client_ad,
+ self.active_scan_callback_list,
+ self.server_ad,
+ self.active_adv_callback_list)
+
+ def test_ble_gatt_connection_range(self):
+ """Test GATT connection over LE and read RSSI.
+
+ Test will establish a gatt connection between a GATT server and GATT
+ client then read the RSSI for each attenuation until the BLE link get disconnect
+
+ Expected Result:
+ Verify that a connection was established and then disconnected
+ successfully. Verify that the RSSI was read correctly.
+
+ """
+ attenuation = []
+ ble_rssi = []
+ dut_pwlv = []
+ path_loss = []
+ bluetooth_gatt, gatt_callback, adv_callback, gatt_server = establish_ble_connection(
+ self.client_ad, self.server_ad)
+ for atten in self.attenuation_range:
+ ramp_attenuation(self.attenuator, atten)
+ self.log.info('Set attenuation to %d dB', atten)
+ rssi_primary, pwlv_primary = self.get_ble_rssi_and_pwlv()
+ self.log.info(
+ "Dut BLE RSSI:{} and Pwlv:{} with attenuation:{}".format(
+ rssi_primary, pwlv_primary, atten))
+ rssi = self.client_ad.droid.gattClientReadRSSI(gatt_server)
+ if type(rssi_primary) != str:
+ attenuation.append(atten)
+ ble_rssi.append(rssi_primary)
+ dut_pwlv.append(pwlv_primary)
+ path_loss.append(atten + self.system_path_loss)
+ df = pd.DataFrame({
+ 'Attenuation': attenuation,
+ 'BLE_RSSI': ble_rssi,
+ 'Dut_PwLv': dut_pwlv,
+ 'Pathloss': path_loss
+ })
+ filepath = os.path.join(
+ self.log_path, '{}.csv'.format(self.current_test_name))
+ else:
+ self.plot_ble_graph(df)
+ df.to_csv(filepath, encoding='utf-8')
+ raise TestPass('Reached BLE Max Range, BLE Gatt disconnected')
+ ble_gatt_disconnection(self.client_ad, bluetooth_gatt, gatt_callback)
+ self.plot_ble_graph(df)
+ df.to_csv(filepath, encoding='utf-8')
+ self.server_ad.droid.bleStopBleAdvertising(adv_callback)
+ return True
+
+ def test_ble_coc_throughput_range(self):
+ """Test LE CoC data transfer and read RSSI with each attenuation
+
+ Test will establish a L2CAP CoC connection between client and server
+ then start BLE date transfer and read the RSSI for each attenuation
+ until the BLE link get disconnect
+
+ Expected Result:
+ BLE data transfer successful and Read RSSi Value of the server
+
+ """
+ attenuation = []
+ ble_rssi = []
+ throughput = []
+ dut_pwlv = []
+ path_loss = []
+ self.plot_throughput = bokeh_figure.BokehFigure(
+ title='{}'.format(self.current_test_name),
+ x_label='Pathloss (dB)',
+ primary_y_label='BLE Throughput (bits per sec)',
+ axis_label_size='16pt')
+ status, gatt_callback, gatt_server, bluetooth_gatt, client_conn_id = ble_coc_connection(
+ self.server_ad, self.client_ad)
+ for atten in self.attenuation_range:
+ ramp_attenuation(self.attenuator, atten)
+ self.log.info('Set attenuation to %d dB', atten)
+ datarate = run_ble_throughput(self.client_ad, client_conn_id,
+ self.server_ad)
+ rssi_primary, pwlv_primary = self.get_ble_rssi_and_pwlv()
+ self.log.info(
+ "BLE RSSI is:{} dBm and Tx Power:{} with attenuation {} dB with throughput:{}bits per sec"
+ .format(rssi_primary, pwlv_primary, atten, datarate))
+ if type(rssi_primary) != str:
+ attenuation.append(atten)
+ ble_rssi.append(rssi_primary)
+ dut_pwlv.append(pwlv_primary)
+ throughput.append(datarate)
+ path_loss.append(atten + self.system_path_loss)
+ df = pd.DataFrame({
+ 'Attenuation': attenuation,
+ 'BLE_RSSI': ble_rssi,
+ 'Dut_PwLv': dut_pwlv,
+ 'Throughput': throughput,
+ 'Pathloss': path_loss
+ })
+ filepath = os.path.join(
+ self.log_path, '{}.csv'.format(self.current_test_name))
+ results_file_path = os.path.join(
+ self.log_path,
+ '{}_throughput.html'.format(self.current_test_name))
+ self.plot_throughput.add_line(df['Pathloss'],
+ df['Throughput'],
+ legend='BLE Throughput',
+ marker='square_x')
+ else:
+ self.plot_ble_graph(df)
+ self.plot_throughput.generate_figure()
+ bokeh_figure.BokehFigure.save_figures([self.plot_throughput],
+ results_file_path)
+ df.to_csv(filepath, encoding='utf-8')
+ raise TestPass('Reached BLE Max Range, BLE Gatt disconnected')
+ self.plot_ble_graph(df)
+ self.plot_throughput.generate_figure()
+ bokeh_figure.BokehFigure.save_figures([self.plot_throughput],
+ results_file_path)
+ df.to_csv(filepath, encoding='utf-8')
+ ble_gatt_disconnection(self.server_ad, bluetooth_gatt, gatt_callback)
+ return True
+
+ def test_ble_scan_remote_rssi(self):
+ data_points = []
+ for atten in self.attenuation_range:
+ csv_path = os.path.join(
+ self.log_path,
+ '{}_attenuation_{}.csv'.format(self.current_test_name, atten))
+ ramp_attenuation(self.attenuator, atten)
+ self.log.info('Set attenuation to %d dB', atten)
+ adv_callback, scan_callback = start_advertising_and_scanning(
+ self.client_ad, self.server_ad, Legacymode=False)
+ self.active_adv_callback_list.append(adv_callback)
+ self.active_scan_callback_list.append(scan_callback)
+ average_rssi, raw_rssi, timestamp = read_ble_scan_rssi(
+ self.client_ad, scan_callback)
+ self.log.info(
+ "Scanned rssi list of the remote device is :{}".format(
+ raw_rssi))
+ self.log.info(
+ "BLE RSSI of the remote device is:{} dBm".format(average_rssi))
+ min_rssi = min(raw_rssi)
+ max_rssi = max(raw_rssi)
+ path_loss = atten + self.system_path_loss
+ std_deviation = np.std(raw_rssi)
+ data_point = {
+ 'Attenuation': atten,
+ 'BLE_RSSI': average_rssi,
+ 'Pathloss': path_loss,
+ 'Min_RSSI': min_rssi,
+ 'Max_RSSI': max_rssi,
+ 'Standard_deviation': std_deviation
+ }
+ data_points.append(data_point)
+ df = pd.DataFrame({'timestamp': timestamp, 'raw rssi': raw_rssi})
+ df.to_csv(csv_path, encoding='utf-8', index=False)
+ try:
+ self.server_ad.droid.bleAdvSetStopAdvertisingSet(adv_callback)
+ except Exception as err:
+ self.log.warning(
+ "Failed to stop advertisement: {}".format(err))
+ reset_bluetooth([self.server_ad])
+ self.client_ad.droid.bleStopBleScan(scan_callback)
+ filepath = os.path.join(
+ self.log_path, '{}_summary.csv'.format(self.current_test_name))
+ ble_df = pd.DataFrame(data_points)
+ ble_df.to_csv(filepath, encoding='utf-8')
+ return True
+
+ def plot_ble_graph(self, df):
+ """ Plotting BLE RSSI and Throughput with Attenuation.
+
+ Args:
+ df: Summary of results contains attenuation, BLE_RSSI and Throughput
+ """
+ self.plot.add_line(df['Pathloss'],
+ df['BLE_RSSI'],
+ legend='DUT BLE RSSI (dBm)',
+ marker='circle_x')
+ self.plot.add_line(df['Pathloss'],
+ df['Dut_PwLv'],
+ legend='DUT TX Power (dBm)',
+ marker='hex',
+ y_axis='secondary')
+ results_file_path = os.path.join(
+ self.log_path, '{}.html'.format(self.current_test_name))
+ self.plot.generate_figure()
+ bokeh_figure.BokehFigure.save_figures([self.plot], results_file_path)
+
+ def get_ble_rssi_and_pwlv(self):
+ process_data_dict = btutils.get_bt_metric(self.client_ad)
+ rssi_primary = process_data_dict.get('rssi')
+ pwlv_primary = process_data_dict.get('pwlv')
+ rssi_primary = rssi_primary.get(self.client_ad.serial)
+ pwlv_primary = pwlv_primary.get(self.client_ad.serial)
+ return rssi_primary, pwlv_primary
diff --git a/acts_tests/tests/google/bt/car_bt/BtCarPairedConnectDisconnectTest.py b/acts_tests/tests/google/bt/car_bt/BtCarPairedConnectDisconnectTest.py
index eb2a06c..82751af 100644
--- a/acts_tests/tests/google/bt/car_bt/BtCarPairedConnectDisconnectTest.py
+++ b/acts_tests/tests/google/bt/car_bt/BtCarPairedConnectDisconnectTest.py
@@ -79,9 +79,9 @@
self.car.droid.bluetoothHfpClientSetPriority(
self.ph.droid.bluetoothGetLocalAddress(),
BtEnum.BluetoothPriorityLevel.PRIORITY_OFF.value)
- self.ph.droid.bluetoothHspSetPriority(
+ self.ph.droid.bluetoothHspSetConnectionPolicy(
self.car.droid.bluetoothGetLocalAddress(),
- BtEnum.BluetoothPriorityLevel.PRIORITY_OFF.value)
+ BtEnum.BluetoothConnectionPolicy.CONNECTION_POLICY_FORBIDDEN.value)
addr = self.ph.droid.bluetoothGetLocalAddress()
if not bt_test_utils.connect_pri_to_sec(
self.car, self.ph,
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpDynamicChannelTest.py b/acts_tests/tests/google/bt/performance/BtA2dpDynamicChannelTest.py
new file mode 100644
index 0000000..0ee137c
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/BtA2dpDynamicChannelTest.py
@@ -0,0 +1,116 @@
+#!/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
+import os
+import logging
+import acts_contrib.test_utils.bt.bt_test_utils as btutils
+import acts_contrib.test_utils.coex.audio_test_utils as atu
+from acts import asserts
+from acts_contrib.test_utils.bt.A2dpBaseTest import A2dpBaseTest
+from acts.signals import TestFailure
+
+INIT_ATTEN = 0
+WAIT_TIME = 2
+
+
+class BtA2dpDynamicChannelTest(A2dpBaseTest):
+ def __init__(self, configs):
+ super().__init__(configs)
+ req_params = ['codecs', 'rssi_profile_params']
+ # 'rssi_profile_params' is a dict containing,a list of upper_bound,
+ # lower_bound attenuation values, Dwell time for RSSI and the test duration
+ # ex:- "rssi_profile_params": {
+ # "upper_bound": [15, 25],
+ # "RSSI_Dwell_time": [1, 1],
+ # "lower_bound": [35, 45],
+ # "test_duration": 30}
+ # 'codecs' is a list containing all codecs required in the tests
+ self.unpack_userparams(req_params)
+ self.upper_bound = self.rssi_profile_params['upper_bound']
+ self.lower_bound = self.rssi_profile_params['lower_bound']
+ self.dwell_time = self.rssi_profile_params['RSSI_Dwell_time']
+ for upper_bound, lower_bound, dwell_time in zip(
+ self.upper_bound, self.lower_bound, self.dwell_time):
+ for codec_config in self.codecs:
+ self.generate_test_case(codec_config, upper_bound, lower_bound,
+ dwell_time)
+
+ def setup_class(self):
+ super().setup_class()
+ # Enable BQR on all android devices
+ btutils.enable_bqr(self.android_devices)
+ self.log_path = os.path.join(logging.log_path, 'results')
+
+ def teardown_class(self):
+ super().teardown_class()
+
+ def generate_test_case(self, codec_config, upper_bound, lower_bound,
+ dwell_time):
+ def test_case_fn():
+ self.check_audio_quality_dynamic_rssi(upper_bound, lower_bound,
+ dwell_time)
+
+ test_case_name = 'test_bt_a2dp_Dynamic_channel_between_attenuation_{}dB_and_{}dB' \
+ '_codec_{}'.format(upper_bound, lower_bound, codec_config['codec_type'])
+ setattr(self, test_case_name, test_case_fn)
+
+ def check_audio_quality_dynamic_rssi(self, upper_bound, lower_bound,
+ dwell_time):
+ tag = 'Dynamic_RSSI'
+ self.media.play()
+ proc = self.audio_device.start()
+ self.inject_rssi_profile(upper_bound, lower_bound, dwell_time)
+ proc.kill()
+ time.sleep(WAIT_TIME)
+ proc.kill()
+ audio_captured = self.audio_device.stop()
+ self.media.stop()
+ self.log.info('Audio play and record stopped')
+ asserts.assert_true(audio_captured, 'Audio not recorded')
+ audio_result = atu.AudioCaptureResult(audio_captured,
+ self.audio_params)
+ thdn = audio_result.THDN(**self.audio_params['thdn_params'])
+ self.log.info('THDN is {}'.format(thdn[0]))
+ # Reading DUT RSSI to check the RSSI fluctuation from
+ # upper and lower bound attenuation values
+ self.attenuator.set_atten(upper_bound)
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics(tag)
+ rssi_l1 = rssi_master.get(self.dut.serial, -127)
+ pwlv_l1 = pwl_master.get(self.dut.serial, -127)
+ self.attenuator.set_atten(lower_bound)
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics(tag)
+ rssi_l2 = rssi_master.get(self.dut.serial, -127)
+ pwlv_l2 = pwl_master.get(self.dut.serial, -127)
+ self.log.info(
+ "DUT RSSI is fluctuating between {} and {} dBm with {}sec interval"
+ .format(rssi_l1, rssi_l2, dwell_time))
+ if thdn[0] > self.audio_params['thdn_threshold'] or thdn[0] == 0:
+ raise TestFailure('Observed audio glitches!')
+
+ def inject_rssi_profile(self, upper_bound, lower_bound, dwell_time):
+ end_time = time.time() + self.rssi_profile_params['test_duration']
+ self.log.info("Testing dynamic channel RSSI")
+ while time.time() < end_time:
+ self.attenuator.set_atten(upper_bound)
+ time.sleep(dwell_time)
+ self.attenuator.set_atten(lower_bound)
+ time.sleep(dwell_time)
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py b/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
index d2bcb10..c775dd7 100644
--- a/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeTest.py
@@ -13,23 +13,16 @@
# 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 pandas as pd
import acts_contrib.test_utils.bt.bt_test_utils as btutils
-import acts_contrib.test_utils.wifi.wifi_performance_test_utils as wifi_utils
from acts import asserts
-from acts_contrib.test_utils.bt import bt_constants
-from acts_contrib.test_utils.bt import BtEnum
from acts_contrib.test_utils.bt.A2dpBaseTest import A2dpBaseTest
-from acts_contrib.test_utils.bt.loggers import bluetooth_metric_logger as log
-from acts_contrib.test_utils.power.PowerBTBaseTest import ramp_attenuation
-from acts.signals import TestPass
+
+INIT_ATTEN = 0
class BtA2dpRangeTest(A2dpBaseTest):
def __init__(self, configs):
super().__init__(configs)
- self.bt_logger = log.BluetoothMetricLogger.for_test_case()
req_params = ['attenuation_vector', 'codecs']
#'attenuation_vector' is a dict containing: start, stop and step of
#attenuation changes
@@ -40,151 +33,30 @@
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:
+ 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)
+
+ def teardown_class(self):
+ super().teardown_class()
+ if hasattr(self, 'atten_c0') and hasattr(self, 'atten_c1'):
+ 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)
- test_case_name = 'test_bt_a2dp_range_codec_{}'.format(
- codec_config['codec_type'])
- setattr(self, test_case_name, test_case_fn)
-
- def generate_proto(self, data_points, codec_type, sample_rate,
- bits_per_sample, channel_mode):
- """Generate a results protobuf.
-
- Args:
- data_points: list of dicts representing info to go into
- AudioTestDataPoint protobuffer message.
- codec_type: The codec type config to store in the proto.
- sample_rate: The sample rate config to store in the proto.
- bits_per_sample: The bits per sample config to store in the proto.
- channel_mode: The channel mode config to store in the proto.
- Returns:
- dict: Dictionary with key 'proto' mapping to serialized protobuf,
- 'proto_ascii' mapping to human readable protobuf info, and 'test'
- mapping to the test class name that generated the results.
- """
-
- # Populate protobuf
- test_case_proto = self.bt_logger.proto_module.BluetoothAudioTestResult(
- )
-
- for data_point in data_points:
- audio_data_proto = test_case_proto.data_points.add()
- log.recursive_assign(audio_data_proto, data_point)
-
- codec_proto = test_case_proto.a2dp_codec_config
- codec_proto.codec_type = bt_constants.codec_types[codec_type]
- codec_proto.sample_rate = int(sample_rate)
- codec_proto.bits_per_sample = int(bits_per_sample)
- codec_proto.channel_mode = bt_constants.channel_modes[channel_mode]
-
- self.bt_logger.add_config_data_to_proto(test_case_proto, self.dut,
- self.bt_device)
-
- self.bt_logger.add_proto_to_results(test_case_proto,
- self.__class__.__name__)
-
- proto_dict = self.bt_logger.get_proto_dict(self.__class__.__name__,
- test_case_proto)
- del proto_dict["proto_ascii"]
- return proto_dict
-
- def plot_graph(self, df):
- """ Plotting A2DP DUT RSSI, remote RSSI and TX Power with Attenuation.
-
- Args:
- df: Summary of results contains attenuation, DUT RSSI, remote RSSI and Tx Power
- """
- self.plot = wifi_utils.BokehFigure(title='{}'.format(
- self.current_test_name),
- x_label='Pathloss (dBm)',
- primary_y_label='RSSI (dBm)',
- secondary_y_label='TX Power (dBm)',
- axis_label_size='16pt')
- self.plot.add_line(df.index,
- df['rssi_primary'],
- legend='DUT RSSI (dBm)',
- marker='circle_x')
- self.plot.add_line(df.index,
- df['rssi_secondary'],
- legend='Remote RSSI (dBm)',
- marker='square_x')
- self.plot.add_line(df.index,
- df['tx_power_level_master'],
- legend='DUT TX Power (dBm)',
- marker='hex',
- y_axis='secondary')
-
- results_file_path = os.path.join(
- self.log_path, '{}.html'.format(self.current_test_name))
- self.plot.generate_figure()
- wifi_utils.BokehFigure.save_figures([self.plot], results_file_path)
-
- def run_a2dp_to_max_range(self, codec_config):
- attenuation_range = range(self.attenuation_vector['start'],
- self.attenuation_vector['stop'] + 1,
- self.attenuation_vector['step'])
-
- data_points = []
- self.file_output = os.path.join(
- self.log_path, '{}.csv'.format(self.current_test_name))
-
- # Set Codec if needed
- current_codec = self.dut.droid.bluetoothA2dpGetCurrentCodecConfig()
- current_codec_type = BtEnum.BluetoothA2dpCodecType(
- current_codec['codecType']).name
- if current_codec_type != codec_config['codec_type']:
- codec_set = btutils.set_bluetooth_codec(self.dut, **codec_config)
- asserts.assert_true(codec_set, 'Codec configuration failed.')
+ 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)
else:
- self.log.info('Current codec is {}, no need to change'.format(
- current_codec_type))
-
- #loop RSSI with the same codec setting
- for atten in attenuation_range:
- ramp_attenuation(self.attenuator, atten)
- self.log.info('Set attenuation to %d dB', atten)
-
- tag = 'codec_{}_attenuation_{}dB_'.format(
- codec_config['codec_type'], atten)
- recorded_file = self.play_and_record_audio(
- self.audio_params['duration'])
- [rssi_master, pwl_master, rssi_slave] = self._get_bt_link_metrics()
- thdns = self.run_thdn_analysis(recorded_file, tag)
- # Collect Metrics for dashboard
- data_point = {
- 'attenuation_db': int(self.attenuator.get_atten()),
- 'rssi_primary': rssi_master[self.dut.serial],
- 'tx_power_level_master': pwl_master[self.dut.serial],
- 'rssi_secondary': rssi_slave[self.bt_device_controller.serial],
- 'total_harmonic_distortion_plus_noise_percent': thdns[0] * 100
- }
- data_points.append(data_point)
- self.log.info(data_point)
- A2dpRange_df = pd.DataFrame(data_points)
-
- # Check thdn for glitches, stop if max range reached
- for thdn in thdns:
- if thdn >= self.audio_params['thdn_threshold']:
- self.log.info(
- 'Max range at attenuation {} dB'.format(atten))
- self.log.info('DUT rssi {} dBm, DUT tx power level {}, '
- 'Remote rssi {} dBm'.format(
- rssi_master, pwl_master, rssi_slave))
- proto_dict = self.generate_proto(data_points,
- **codec_config)
- A2dpRange_df.to_csv(self.file_output, index=False)
- self.plot_graph(A2dpRange_df)
- raise TestPass('Max range reached and move to next codec',
- extras=proto_dict)
- # Save Data points to csv
- A2dpRange_df.to_csv(self.file_output, index=False)
- # Plot graph
- self.plot_graph(A2dpRange_df)
- proto_dict = self.generate_proto(data_points, **codec_config)
- raise TestPass('Could not reach max range, need extra attenuation.',
- extras=proto_dict)
\ No newline at end of file
+ test_case_name = 'test_bt_a2dp_range_codec_{}'.format(
+ codec_config['codec_type'])
+ setattr(self, test_case_name, test_case_fn)
diff --git a/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py
new file mode 100644
index 0000000..5fe9503
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleAdvTest.py
@@ -0,0 +1,142 @@
+#!/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 acts_contrib.test_utils.bt.bt_test_utils as btutils
+from acts_contrib.test_utils.bt.bt_constants import adv_succ
+from acts_contrib.test_utils.bt.A2dpBaseTest import A2dpBaseTest
+from acts_contrib.test_utils.bt.bt_constants import bt_default_timeout
+from acts_contrib.test_utils.bt.bt_constants import ble_advertise_settings_modes
+from acts_contrib.test_utils.bt.bt_constants import ble_advertise_settings_tx_powers
+from acts_contrib.test_utils.bt.bt_test_utils import BtTestUtilsError
+from queue import Empty
+from acts_contrib.test_utils.bt.bt_test_utils import generate_ble_advertise_objects
+from acts_contrib.test_utils.bt.bt_test_utils import setup_multiple_devices_for_bt_test
+
+INIT_ATTEN = 0
+
+
+class BtA2dpRangeWithBleAdvTest(A2dpBaseTest):
+ """User can generate test case with below format.
+ test_bt_a2dp_range_codec_"Codec"_adv_mode_"Adv Mode"_adv_tx_power_"Adv Tx Power"
+
+ Below are the list of test cases:
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_power_adv_tx_power_ultra_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_power_adv_tx_power_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_power_adv_tx_power_medium
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_power_adv_tx_power_high
+ test_bt_a2dp_range_codec_AAC_adv_mode_balanced_adv_tx_power_ultra_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_balanced_adv_tx_power_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_balanced_adv_tx_power_medium
+ test_bt_a2dp_range_codec_AAC_adv_mode_balanced_adv_tx_power_high
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_latency_adv_tx_power_ultra_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_latency_adv_tx_power_low
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_latency_adv_tx_power_medium
+ test_bt_a2dp_range_codec_AAC_adv_mode_low_latency_adv_tx_power_high
+ test_bt_a2dp_range_codec_SBC_adv_mode_low_power_adv_tx_power_ultra_low
+ test_bt_a2dp_range_codec_SBC_adv_mode_low_power_adv_tx_power_low
+ test_bt_a2dp_range_codec_SBC_adv_mode_low_power_adv_tx_power_medium
+ test_bt_a2dp_range_codec_SBC_adv_mode_low_power_adv_tx_power_high
+ test_bt_a2dp_range_codec_SBC_adv_mode_balanced_adv_tx_power_ultra_low
+ test_bt_a2dp_range_codec_SBC_adv_mode_balanced_adv_tx_power_low
+ test_bt_a2dp_range_codec_SBC_adv_mode_balanced_adv_tx_power_medium
+ test_bt_a2dp_range_codec_SBC_adv_mode_balanced_adv_tx_power_high
+ test_bt_a2dp_range_codec_SBC_adv_mode_low_latency_adv_tx_power_ultra_low
+ 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
+ #'codecs' is a list containing all codecs required in the tests
+ self.unpack_userparams(req_params)
+ 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)
+
+ 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
+ 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)
+
+ def teardown_class(self):
+ super().teardown_class()
+ if hasattr(self, 'atten_c0') and hasattr(self, 'atten_c1'):
+ 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")
+
+ 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)
+ 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)
+
+ def start_ble_adv(self, adv_mode, adv_power_level):
+ """Function to start an LE advertisement
+ Steps:
+ 1. Create a advertise data object
+ 2. Create a advertise settings object.
+ 3. Create a advertise callback object.
+ 4. Start an LE advertising using the objects created in steps 1-3.
+ 5. Find the onSuccess advertisement event.
+
+ Expected Result:
+ Advertisement is successfully advertising.
+
+ Returns:
+ Returns advertise call back"""
+
+ self.dut.droid.bleSetAdvertiseDataIncludeDeviceName(True)
+ self.dut.droid.bleSetAdvertiseSettingsAdvertiseMode(adv_mode)
+ self.dut.droid.bleSetAdvertiseSettingsIsConnectable(True)
+ self.dut.droid.bleSetAdvertiseSettingsTxPowerLevel(adv_power_level)
+ advertise_callback, advertise_data, advertise_settings = (
+ generate_ble_advertise_objects(self.dut.droid))
+ self.dut.droid.bleStartBleAdvertising(advertise_callback,
+ advertise_data,
+ advertise_settings)
+ try:
+ self.dut.ed.pop_event(adv_succ.format(advertise_callback),
+ bt_default_timeout)
+ self.log.info("Advertisement started successfully")
+ except Empty as err:
+ 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
new file mode 100644
index 0000000..6020c4a
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/BtA2dpRangeWithBleScanTest.py
@@ -0,0 +1,103 @@
+#!/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 acts_contrib.test_utils.bt.bt_test_utils as btutils
+from acts_contrib.test_utils.bt.A2dpBaseTest import A2dpBaseTest
+from acts_contrib.test_utils.bt.bt_constants import ble_scan_settings_modes
+from acts_contrib.test_utils.bt.bt_test_utils import generate_ble_scan_objects
+from acts_contrib.test_utils.bt.bt_test_utils import setup_multiple_devices_for_bt_test
+from acts_contrib.test_utils.bt.bt_constants import scan_result
+
+INIT_ATTEN = 0
+
+
+class BtA2dpRangeWithBleScanTest(A2dpBaseTest):
+ default_timeout = 10
+
+ 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
+ #'codecs' is a list containing all codecs required in the tests
+ self.unpack_userparams(req_params)
+ 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)
+
+ 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
+ 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)
+
+ def teardown_class(self):
+ super().teardown_class()
+ if hasattr(self, 'atten_c0') and hasattr(self, 'atten_c1'):
+ 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")
+
+ 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)
+ 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)
+
+ def start_ble_scan(self, scan_mode):
+ """ This function will start Ble Scan with different scan mode.
+
+ Args:
+ Scan_mode: Ble scan setting modes
+
+ returns:
+ Scan_callback: Ble scan callback
+ """
+
+ self.dut.droid.bleSetScanSettingsScanMode(scan_mode)
+ filter_list, scan_settings, scan_callback = generate_ble_scan_objects(
+ self.dut.droid)
+ self.dut.droid.bleStartBleScan(filter_list, scan_settings,
+ scan_callback)
+ self.log.info("BLE Scanning started succssfully")
+ return scan_callback
diff --git a/acts_tests/tests/google/bt/performance/BtInterferenceDynamicTest.py b/acts_tests/tests/google/bt/performance/BtInterferenceDynamicTest.py
index 59721ca..ec980a2 100644
--- a/acts_tests/tests/google/bt/performance/BtInterferenceDynamicTest.py
+++ b/acts_tests/tests/google/bt/performance/BtInterferenceDynamicTest.py
@@ -261,9 +261,13 @@
ramp_attenuation(self.attenuator, bt_atten_level)
self.interference_rssi_mapping_from_attenuation(
interference_atten_level)
- [rssi_master, pwl_master, rssi_slave] = self._get_bt_link_metrics()
- tag_bt = 'bt_signal_level_{}_rssi_{}_dBm'.format(
- bt_atten_level, rssi_master)
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics()
+ rssi_primary = rssi_master.get(self.dut.serial, -127)
+ tag_bt = 'bt_signal_level_{}'.format(
+ bt_atten_level)
procs_iperf = []
for obj in self.wifi_int_pairs:
obj.iperf_server.start()
@@ -313,9 +317,13 @@
ramp_attenuation(self.attenuator, bt_atten_level)
self.interference_rssi_mapping_from_attenuation(
interference_atten_level)
- [rssi_master, pwl_master, rssi_slave] = self._get_bt_link_metrics()
- tag_bt = 'bt_signal_level_{}_rssi_{}_dBm'.format(
- bt_atten_level, rssi_master)
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics()
+ rssi_primary = rssi_master.get(self.dut.serial, -127)
+ tag_bt = 'bt_signal_level_{}'.format(
+ bt_atten_level)
procs_iperf = []
#Start IPERF on all three interference pairs
for obj in self.wifi_int_pairs:
@@ -354,4 +362,4 @@
self.log.info('THDN results are {}'.format(thdns))
for thdn in thdns:
if thdn >= self.audio_params['thdn_threshold']:
- raise TestFailure('AFH failed')
+ raise TestFailure('AFH failed')
\ No newline at end of file
diff --git a/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py b/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
index bf6b0de..99218b0 100644
--- a/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
+++ b/acts_tests/tests/google/bt/performance/BtInterferenceStaticTest.py
@@ -15,11 +15,13 @@
# the License.
"""Stream music through connected device from phone across different
attenuations."""
-from acts.signals import TestPass
+
from acts_contrib.test_utils.bt.BtInterferenceBaseTest import BtInterferenceBaseTest
from acts.metrics.loggers.blackbox import BlackboxMetricLogger
from acts_contrib.test_utils.bt.BtInterferenceBaseTest import get_iperf_results
+from acts_contrib.test_utils.bt.BtInterferenceBaseTest import inject_static_wifi_interference
from multiprocessing import Process, Queue
+from acts.signals import TestPass
DEFAULT_THDN_THRESHOLD = 0.9
MAX_ATTENUATION = 95
@@ -33,8 +35,7 @@
self.attenuation_vector['stop'] + 1,
self.attenuation_vector['step'])
- self.iperf_duration = self.audio_params[
- 'duration'] + TIME_OVERHEAD
+ 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']:
@@ -69,44 +70,6 @@
str_channel_test))
setattr(self, test_case_name, test_case_fn)
- def inject_static_wifi_interference(self, interference_level, channels):
- """Function to inject wifi interference to bt link and read rssi.
-
- Interference of IPERF traffic is always running, by setting attenuation,
- the gate is opened to release the interference to the setup.
- Args:
- interference_level: the signal strength of wifi interference, use
- attenuation level to represent this
- channels: wifi channels where interference will
- be injected, list
- """
- all_pair = range(len(self.wifi_int_pairs))
- interference_pair_indices = self.locate_interference_pair_by_channel(
- channels)
- inactive_interference_pairs_indices = [
- item for item in all_pair if item not in interference_pair_indices
- ]
- self.log.info(
- 'WiFi interference at {} and inactive channels at {}'.format(
- interference_pair_indices,
- inactive_interference_pairs_indices))
- for i in interference_pair_indices:
- self.wifi_int_pairs[i].attenuator.set_atten(interference_level)
- self.log.info('Set attenuation {} dB on attenuator {}'.format(
- self.wifi_int_pairs[i].attenuator.get_atten(), i + 1))
- for i in inactive_interference_pairs_indices:
- self.wifi_int_pairs[i].attenuator.set_atten(MAX_ATTENUATION)
- self.log.info('Set attenuation {} dB on attenuator {}'.format(
- self.wifi_int_pairs[i].attenuator.get_atten(), i + 1))
- #Read interference RSSI
- self.get_interference_rssi()
- self.wifi_chan1_rssi_metric.metric_value = self.interference_rssi[0][
- 'rssi']
- self.wifi_chan6_rssi_metric.metric_value = self.interference_rssi[1][
- 'rssi']
- self.wifi_chan11_rssi_metric.metric_value = self.interference_rssi[2][
- 'rssi']
-
def bt_range_with_static_wifi_interference(self, interference_level,
channels):
"""Test function to measure bt range under interference.
@@ -116,12 +79,28 @@
channels: wifi interference channels
"""
#setup wifi interference by setting the correct attenuator
- self.inject_static_wifi_interference(interference_level, channels)
+ inject_static_wifi_interference(self.wifi_int_pairs,
+ interference_level, channels)
+ # Read interference RSSI
+ self.get_interference_rssi()
+ self.wifi_chan1_rssi_metric.metric_value = self.interference_rssi[0][
+ 'rssi']
+ self.wifi_chan6_rssi_metric.metric_value = self.interference_rssi[1][
+ 'rssi']
+ self.wifi_chan11_rssi_metric.metric_value = self.interference_rssi[2][
+ 'rssi']
for atten in self.bt_attenuation_range:
# Set attenuation for BT link
self.attenuator.set_atten(atten)
- [rssi_master, pwl_master, rssi_slave] = self._get_bt_link_metrics()
- tag = 'attenuation_{}dB_'.format(atten)
+ [
+ rssi_master, pwl_master, rssi_c0_master, rssi_c1_master,
+ txpw_c0_master, txpw_c1_master, bftx_master, divtx_master
+ ], [rssi_slave] = self._get_bt_link_metrics()
+ rssi_primary = rssi_master.get(self.dut.serial, -127)
+ pwl_primary = pwl_master.get(self.dut.serial, -127)
+ rssi_secondary = rssi_slave.get(self.bt_device_controller.serial,
+ -127)
+ tag = 'attenuation_{}dB'.format(atten)
self.log.info(
'BT attenuation set to {} dB and start A2DP streaming'.format(
atten))
@@ -140,8 +119,8 @@
#play a2dp streaming and run thdn analysis
queue = Queue()
- proc_bt = Process(target=self.play_and_record_audio,
- args=(self.audio_params['duration'],queue))
+ proc_bt = Process(target=self.play_and_record_audio,
+ args=(self.audio_params['duration'], queue))
for proc in procs_iperf:
proc.start()
proc_bt.start()
@@ -155,23 +134,23 @@
obj.channel, iperf_throughput))
obj.iperf_server.stop()
self.log.info('Stopped IPERF server at port {}'.format(
- obj.iperf_server.port))
+ obj.iperf_server.port))
audio_captured = queue.get()
thdns = self.run_thdn_analysis(audio_captured, tag)
- self.log.info('THDN results are {} at {} dB attenuation'
- .format(thdns, atten))
- self.log.info('master rssi {} dBm, master tx power level {}, '
- 'slave rssi {} dBm'
- .format(rssi_master, pwl_master, rssi_slave))
+ 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))
for thdn in thdns:
if thdn >= self.audio_params['thdn_threshold']:
self.log.info('Under the WiFi interference condition: '
'channel 1 RSSI: {} dBm, '
'channel 6 RSSI: {} dBm'
- 'channel 11 RSSI: {} dBm'
- .format(self.interference_rssi[0]['rssi'],
- self.interference_rssi[1]['rssi'],
- self.interference_rssi[2]['rssi']))
+ 'channel 11 RSSI: {} dBm'.format(
+ self.interference_rssi[0]['rssi'],
+ self.interference_rssi[1]['rssi'],
+ self.interference_rssi[2]['rssi']))
raise TestPass(
'Max range for this test is {}, with BT master RSSI at'
- ' {} dBm'.format(atten, rssi_master))
+ ' {} dBm'.format(atten, rssi_primary))
diff --git a/acts_tests/tests/google/bt/performance/InjectWifiInterferenceTest.py b/acts_tests/tests/google/bt/performance/InjectWifiInterferenceTest.py
new file mode 100644
index 0000000..22c2b2f
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/InjectWifiInterferenceTest.py
@@ -0,0 +1,190 @@
+#!/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 json
+import random
+import sys
+import logging
+import re
+from acts.base_test import BaseTestClass
+from acts_contrib.test_utils.bt.BtInterferenceBaseTest import inject_static_wifi_interference
+from acts_contrib.test_utils.bt.BtInterferenceBaseTest import unpack_custom_file
+from acts_contrib.test_utils.power.PowerBaseTest import ObjNew
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wpeutils
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+import time
+
+MAX_ATTENUATION = 95
+INIT_ATTEN = 0
+SCAN = 'wpa_cli scan'
+SCAN_RESULTS = 'wpa_cli scan_results'
+
+
+class InjectWifiInterferenceTest(BaseTestClass):
+ def __init__(self, configs):
+ super().__init__(configs)
+ req_params = ['custom_files', 'wifi_networks']
+ self.unpack_userparams(req_params)
+ for file in self.custom_files:
+ if 'static_interference' in file:
+ self.static_wifi_interference = unpack_custom_file(file)
+ elif 'dynamic_interference' in file:
+ self.dynamic_wifi_interference = unpack_custom_file(file)
+
+ def setup_class(self):
+
+ self.dut = self.android_devices[0]
+ # Set attenuator to minimum attenuation
+ if hasattr(self, 'attenuators'):
+ self.attenuator = self.attenuators[0]
+ self.attenuator.set_atten(INIT_ATTEN)
+ self.wifi_int_pairs = []
+ for i in range(len(self.attenuators) - 1):
+ tmp_dict = {
+ 'attenuator': self.attenuators[i + 1],
+ 'network': self.wifi_networks[i],
+ 'channel': self.wifi_networks[i]['channel']
+ }
+ tmp_obj = ObjNew(**tmp_dict)
+ self.wifi_int_pairs.append(tmp_obj)
+ ##Setup connection between WiFi APs and Phones and get DHCP address
+ # for the interface
+ for obj in self.wifi_int_pairs:
+ obj.attenuator.set_atten(INIT_ATTEN)
+
+ def setup_test(self):
+ self.log.info("Setup test initiated")
+
+ def teardown_class(self):
+ for obj in self.wifi_int_pairs:
+ obj.attenuator.set_atten(MAX_ATTENUATION)
+
+ def teardown_test(self):
+ for obj in self.wifi_int_pairs:
+ obj.attenuator.set_atten(MAX_ATTENUATION)
+
+ def test_inject_static_wifi_interference(self):
+ condition = True
+ while condition:
+ attenuation = [
+ int(x) for x in input(
+ "Please enter 4 channel attenuation value followed by comma :\n"
+ ).split(',')
+ ]
+ self.set_atten_all_channel(attenuation)
+ # Read interference RSSI
+ self.interference_rssi = get_interference_rssi(
+ self.dut, self.wifi_int_pairs)
+ self.log.info('Under the WiFi interference condition: '
+ 'channel 1 RSSI: {} dBm, '
+ 'channel 6 RSSI: {} dBm'
+ 'channel 11 RSSI: {} dBm'.format(
+ self.interference_rssi[0]['rssi'],
+ self.interference_rssi[1]['rssi'],
+ self.interference_rssi[2]['rssi']))
+ condition = True
+ return True
+
+ def test_inject_dynamic_interface(self):
+ atten = int(input("Please enter the attenuation level for CHAN1 :"))
+ self.attenuator.set_atten(atten)
+ self.log.info("Attenuation for CHAN1 set to:{} dB".format(atten))
+ interference_rssi = None
+ self.channel_change_interval = self.dynamic_wifi_interference[
+ 'channel_change_interval_second']
+ self.wifi_int_levels = list(
+ self.dynamic_wifi_interference['interference_level'].keys())
+ for wifi_level in self.wifi_int_levels:
+ interference_atten_level = self.dynamic_wifi_interference[
+ 'interference_level'][wifi_level]
+ all_pair = range(len(self.wifi_int_pairs))
+ # Set initial WiFi interference at channel 1
+ logging.info('Start with interference at channel 1')
+ self.wifi_int_pairs[0].attenuator.set_atten(
+ interference_atten_level)
+ self.wifi_int_pairs[1].attenuator.set_atten(MAX_ATTENUATION)
+ self.wifi_int_pairs[2].attenuator.set_atten(MAX_ATTENUATION)
+ current_int_pair = [0]
+ inactive_int_pairs = [
+ item for item in all_pair if item not in current_int_pair
+ ]
+ logging.info(
+ 'Inject random changing channel (1,6,11) wifi interference'
+ 'every {} second'.format(self.channel_change_interval))
+ while True:
+ current_int_pair = [
+ random.randint(inactive_int_pairs[0],
+ inactive_int_pairs[1])
+ ]
+ inactive_int_pairs = [
+ item for item in all_pair if item not in current_int_pair
+ ]
+ self.wifi_int_pairs[current_int_pair[0]].attenuator.set_atten(
+ interference_atten_level)
+ logging.info('Current interference at channel {}'.format(
+ self.wifi_int_pairs[current_int_pair[0]].channel))
+ for i in inactive_int_pairs:
+ self.wifi_int_pairs[i].attenuator.set_atten(
+ MAX_ATTENUATION)
+ # Read interference RSSI
+ self.interference_rssi = get_interference_rssi(
+ self.dut, self.wifi_int_pairs)
+ self.log.info('Under the WiFi interference condition: '
+ 'channel 1 RSSI: {} dBm, '
+ 'channel 6 RSSI: {} dBm'
+ 'channel 11 RSSI: {} dBm'.format(
+ self.interference_rssi[0]['rssi'],
+ self.interference_rssi[1]['rssi'],
+ self.interference_rssi[2]['rssi']))
+ time.sleep(self.channel_change_interval)
+ return True
+
+ def set_atten_all_channel(self, attenuation):
+ self.attenuators[0].set_atten(attenuation[0])
+ self.attenuators[1].set_atten(attenuation[1])
+ self.attenuators[2].set_atten(attenuation[2])
+ self.attenuators[3].set_atten(attenuation[3])
+ self.log.info(
+ "Attenuation set to CHAN1:{},CHAN2:{},CHAN3:{},CHAN4:{}".format(
+ self.attenuators[0].get_atten(),
+ self.attenuators[1].get_atten(),
+ self.attenuators[2].get_atten(),
+ self.attenuators[3].get_atten()))
+
+
+def get_interference_rssi(dut, wifi_int_pairs):
+ """Function to read wifi interference RSSI level."""
+
+ bssids = []
+ interference_rssi = []
+ wutils.wifi_toggle_state(dut, True)
+ for item in wifi_int_pairs:
+ ssid = item.network['SSID']
+ bssid = item.network['bssid']
+ bssids.append(bssid)
+ interference_rssi_dict = {
+ "ssid": ssid,
+ "bssid": bssid,
+ "chan": item.channel,
+ "rssi": 0
+ }
+ interference_rssi.append(interference_rssi_dict)
+ scaned_rssi = wpeutils.get_scan_rssi(dut, bssids, num_measurements=2)
+ for item in interference_rssi:
+ item['rssi'] = scaned_rssi[item['bssid']]['mean']
+ logging.info('Interference RSSI at channel {} is {} dBm'.format(
+ item['chan'], item['rssi']))
+ wutils.wifi_toggle_state(dut, False)
+ return interference_rssi
diff --git a/acts_tests/tests/google/bt/performance/StartIperfTrafficTest.py b/acts_tests/tests/google/bt/performance/StartIperfTrafficTest.py
new file mode 100644
index 0000000..edc373f
--- /dev/null
+++ b/acts_tests/tests/google/bt/performance/StartIperfTrafficTest.py
@@ -0,0 +1,102 @@
+#!/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 sys
+import time
+import acts.controllers.iperf_client as ipc
+from acts_contrib.test_utils.bt.BtInterferenceBaseTest import BtInterferenceBaseTest
+from acts_contrib.test_utils.power.PowerBaseTest import ObjNew
+from multiprocessing import Process, Queue
+from acts_contrib.test_utils.bt.BtInterferenceBaseTest import setup_ap_connection
+from acts_contrib.test_utils.wifi import wifi_power_test_utils as wputils
+from acts.signals import TestPass
+
+
+class StartIperfTrafficTest(BtInterferenceBaseTest):
+ """
+ """
+ def __init__(self, configs):
+ super().__init__(configs)
+ req_params =["IperfDuration"]
+ self.unpack_userparams(req_params)
+
+ def setup_class(self):
+ self.dut = self.android_devices[0]
+ self.wifi_int_pairs = []
+ for i in range(len(self.attenuators) - 1):
+ tmp_dict = {
+ 'dut': self.android_devices[i],
+ 'ap': self.access_points[i],
+ 'network': self.wifi_networks[i],
+ 'channel': self.wifi_networks[i]['channel'],
+ 'iperf_server': self.iperf_servers[i],
+ 'ether_int': self.packet_senders[i],
+ 'iperf_client': ipc.IPerfClientOverAdb(self.android_devices[i])
+ }
+ tmp_obj = ObjNew(**tmp_dict)
+ self.wifi_int_pairs.append(tmp_obj)
+ ##Setup connection between WiFi APs and Phones and get DHCP address
+ # for the interface
+ for obj in self.wifi_int_pairs:
+ brconfigs = setup_ap_connection(obj.dut, obj.network, obj.ap)
+ iperf_server_address = wputils.wait_for_dhcp(
+ obj.ether_int.interface)
+ setattr(obj, 'server_address', iperf_server_address)
+ setattr(obj, 'brconfigs', brconfigs)
+
+ def setup_test(self):
+ self.log.info("Setup test initiated")
+
+ def teardown_class(self):
+ for obj in self.wifi_int_pairs:
+ obj.ap.bridge.teardown(obj.brconfigs)
+ self.log.info('Stop IPERF server at port {}'.format(
+ obj.iperf_server.port))
+ obj.iperf_server.stop()
+ self.log.info('Stop IPERF process on {}'.format(obj.dut.serial))
+ #obj.dut.adb.shell('pkill -9 iperf3')
+ #only for glinux machine
+ # wputils.bring_down_interface(obj.ether_int.interface)
+ obj.ap.close()
+
+ def teardown_test(self):
+ self.log.info("Setup test initiated")
+
+ def test_start_iperf_traffic(self):
+ self.channel_change_interval = self.dynamic_wifi_interference[
+ 'channel_change_interval_second']
+ self.wifi_int_levels = list(
+ self.dynamic_wifi_interference['interference_level'].keys())
+ for wifi_level in self.wifi_int_levels:
+ interference_atten_level = self.dynamic_wifi_interference[
+ 'interference_level'][wifi_level]
+ end_time = time.time() + self.IperfDuration
+ while time.time() < end_time:
+ procs_iperf = []
+ # Start IPERF on all three interference pairs
+ for obj in self.wifi_int_pairs:
+ obj.iperf_server.start()
+ iperf_args = '-i 1 -t {} -p {} -J -R'.format(
+ self.IperfDuration, obj.iperf_server.port)
+ tag = 'chan_{}'.format(obj.channel)
+ proc_iperf = Process(target=obj.iperf_client.start,
+ args=(obj.server_address, iperf_args,
+ tag))
+ proc_iperf.start()
+ procs_iperf.append(proc_iperf)
+ for proc in procs_iperf:
+ self.log.info('Started IPERF on all three channels')
+ proc.join()
+ return True
diff --git a/acts_tests/tests/google/gnss/GnssBlankingThTest.py b/acts_tests/tests/google/gnss/GnssBlankingThTest.py
new file mode 100644
index 0000000..e625171
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssBlankingThTest.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+#
+# 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.
+
+from acts_contrib.test_utils.gnss.GnssBlankingBase import GnssBlankingBase
+
+
+class GnssBlankingThTest(GnssBlankingBase):
+ """ LAB GNSS Cellular Coex Tx Power Sweep TTFF/FFPE Tests"""
+
+ def gnss_wwan_blanking_sweep_base(self):
+ """
+ GNSS WWAN blanking cellular power sweep base function
+ """
+ # Get parameters from user params.
+ 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)
+ 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()
+
+ def test_gnss_gsm850_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep GSM850, Ch190.
+ """
+ self.eecoex_func = 'CELLR,2,850,190,1,1,{}'
+ self.start_pwr = self.gsm_sweep_params[0]
+ self.stop_pwr = self.gsm_sweep_params[1]
+ self.offset = self.gsm_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_gsm900_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep GSM900, Ch20.
+ """
+ self.eecoex_func = 'CELLR,2,900,20,1,1,{}'
+ self.start_pwr = self.gsm_sweep_params[0]
+ self.stop_pwr = self.gsm_sweep_params[1]
+ self.offset = self.gsm_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_gsm1800_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep GSM1800, Ch699.
+ """
+ self.eecoex_func = 'CELLR,2,1800,699,1,1,{}'
+ self.start_pwr = self.gsm_sweep_params[0]
+ self.stop_pwr = self.gsm_sweep_params[1]
+ self.offset = self.gsm_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_gsm1900_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep GSM1900, Ch661.
+ """
+ self.eecoex_func = 'CELLR,2,1900,661,1,1,{}'
+ self.start_pwr = self.gsm_sweep_params[0]
+ self.stop_pwr = self.gsm_sweep_params[1]
+ self.offset = self.gsm_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b38_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B38, 10M, 12RB@0, Ch38000.
+ """
+ self.eecoex_func = 'CELLR,5,38,38000,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b39_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B39, 10M, 12RB@0, Ch38450.
+ """
+ self.eecoex_func = 'CELLR,5,39,38450,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b40_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B40, 10M, 12RB@0, Ch39150.
+ """
+ self.eecoex_func = 'CELLR,5,40,39150,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b41_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B41, 10M, 12RB@0, Ch40620.
+ """
+ self.eecoex_func = 'CELLR,5,41,40620,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b42_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B42, 10M, 12RB@0, Ch42590.
+ """
+ self.eecoex_func = 'CELLR,5,42,42590,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_lte_b48_sweep(self):
+ """
+ GNSS WWAN blanking cellular power sweep LTE-TDD, B48, 10M, 12RB@0, Ch55990.
+ """
+ self.eecoex_func = 'CELLR,5,48,55990,true,PRIMARY,{},10MHz,0,12'
+ self.start_pwr = self.lte_tdd_pc3_sweep_params[0]
+ self.stop_pwr = self.lte_tdd_pc3_sweep_params[1]
+ self.offset = self.lte_tdd_pc3_sweep_params[2]
+ self.gnss_wwan_blanking_sweep_base()
+
+ def test_gnss_stand_alone_gnss(self):
+ """
+ GNSS stand alone test item.
+ """
+ self.eecoex_func = ''
+ self.start_pwr = 0
+ self.stop_pwr = 0
+ self.offset = 0
+ self.gnss_wwan_blanking_sweep_base()
diff --git a/acts_tests/tests/google/gnss/GnssConcurrencyTest.py b/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
index c03ea08..9169f4e 100644
--- a/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
+++ b/acts_tests/tests/google/gnss/GnssConcurrencyTest.py
@@ -16,9 +16,11 @@
import time
import datetime
+import re
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.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
@@ -39,12 +41,17 @@
self.ad = self.android_devices[0]
req_params = [
"standalone_cs_criteria", "chre_tolerate_rate", "qdsp6m_path",
- "outlier_criteria", "max_outliers"
+ "outlier_criteria", "max_outliers", "pixel_lab_location",
+ "max_interval", "onchip_interval"
]
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.clear_logd_gnss_qxdm_log(self.ad)
gutils.start_pixel_logger(self.ad)
start_adb_tcpdump(self.ad)
# related properties
@@ -61,6 +68,11 @@
gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path)
get_tcpdump_log(self.ad, test_name, begin_time)
+ def is_brcm_test(self):
+ """ Check the test is for BRCM and skip if not. """
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ raise signals.TestSkip("Not BRCM chipset. Skip the test.")
+
def load_chre_nanoapp(self):
""" Load CHRE nanoapp to target Android Device. """
for _ in range(0, 3):
@@ -76,7 +88,7 @@
else:
raise signals.TestError("Failed to load CHRE nanoapp")
- def enable_gnss_concurrency(self, freq):
+ def enable_chre(self, freq):
""" Enable or disable gnss concurrency via nanoapp.
Args:
@@ -90,32 +102,14 @@
if "ap" not in type:
self.ad.adb.shell(" ".join([cmd, type, option]))
- def run_concurrency_test(self, ap_freq, chre_freq, test_time):
- """ Run the concurrency test with specific sequence.
-
- Args:
- ap_freq: int for AP side location request frequency.
- chre_freq: int forCHRE side location request frequency.
- test_time: int for test duration.
- Return: test begin time.
- """
- gutils.process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
- begin_time = utils.get_current_epoch_time()
- gutils.start_gnss_by_gtw_gpstool(self.ad, True, freq=ap_freq)
- self.enable_gnss_concurrency(chre_freq)
- time.sleep(test_time)
- self.enable_gnss_concurrency(0)
- gutils.start_gnss_by_gtw_gpstool(self.ad, False)
- return begin_time
-
def parse_concurrency_result(self, begin_time, type, criteria):
""" Parse the test result with given time and criteria.
Args:
begin_time: test begin time.
type: str for location request type.
- criteria: int for test criteria.
- Return: List for the failure and outlier loops.
+ criteria: dictionary for test criteria.
+ Return: List for the failure and outlier loops and results.
"""
results = []
failures = []
@@ -125,6 +119,9 @@
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
@@ -151,53 +148,193 @@
self.ad.log.info("TestResult %s_max_time %.2f" %
(type, max(results[1:])))
- return outliers, failures
+ return outliers, failures, results
- def execute_gnss_concurrency_test(self, criteria, test_duration):
+ def run_gnss_concurrency_test(self, criteria, test_duration):
""" Execute GNSS concurrency test steps.
Args:
criteria: int for test criteria.
test_duration: int for test duration.
"""
- failures = {}
- outliers = {}
- begin_time = self.run_concurrency_test(criteria["ap_location"],
- criteria["gnss"], test_duration)
- for type in CONCURRENCY_TYPE.keys():
- self.ad.log.info("Starting process %s result" % type)
- outliers[type], failures[type] = self.parse_concurrency_result(
- begin_time, type, criteria[type])
- for type in CONCURRENCY_TYPE.keys():
- if len(failures[type]) > 0:
- raise signals.TestFailure("Test exceeds criteria: %.2f" %
- criteria[type])
- elif len(outliers[type]) > self.max_outliers:
- raise signals.TestFailure("Outliers excceds max amount: %d" %
- len(outliers[type]))
+ 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"])
+ time.sleep(test_duration)
+ self.enable_chre(0)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ self.validate_location_test_result(begin_time, criteria)
- # Test Cases
+ def run_chre_only_test(self, criteria, test_duration):
+ """ Execute CHRE only test steps.
+
+ Args:
+ 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))
+ self.enable_chre(criteria["gnss"])
+ time.sleep(test_duration)
+ self.enable_chre(0)
+ self.validate_location_test_result(begin_time, criteria)
+
+ def validate_location_test_result(self, begin_time, request):
+ """ Validate GNSS concurrency/CHRE test results.
+
+ Args:
+ begin_time: epoc of test begin time
+ request: int for test criteria.
+ """
+ results = {}
+ outliers = {}
+ failures = {}
+ failure_log = ""
+ for request_type, criteria in request.items():
+ criteria = criteria if criteria > 1 else 1
+ 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)
+ 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)
+ if len(outliers[request_type]) > self.max_outliers:
+ failure_log += "[%s] Outliers excceds max amount: %d\n" % (
+ request_type, len(outliers[request_type]))
+
+ if failure_log:
+ raise signals.TestFailure(failure_log)
+
+ def run_engine_switching_test(self, freq):
+ """ Conduct engine switching test with given frequency.
+
+ Args:
+ freq: a list identify source1/2 frequency [freq1, freq2]
+ """
+ request = {"ap_location": self.max_interval}
+ begin_time = utils.get_current_epoch_time()
+ self.ad.droid.startLocating(freq[0] * 1000, 0)
+ time.sleep(10)
+ for i in range(5):
+ gutils.start_gnss_by_gtw_gpstool(self.ad, True, freq=freq[1])
+ time.sleep(10)
+ gutils.start_gnss_by_gtw_gpstool(self.ad, False)
+ self.ad.droid.stopLocating()
+ self.calculate_position_error(begin_time)
+ self.validate_location_test_result(begin_time, request)
+
+ def calculate_position_error(self, begin_time):
+ """ Calculate the position error for the logcat search results.
+
+ Args:
+ begin_time: test begin time
+ """
+ position_errors = []
+ search_results = self.ad.search_logcat("reportLocation", begin_time)
+ for result in search_results:
+ # search for location like 25.000717,121.455163
+ regex = r"(-?\d{1,5}\.\d{1,10}),\s*(-?\d{1,5}\.\d{1,10})"
+ result = re.search(regex, result["log_message"])
+ if not result:
+ raise ValueError("lat/lon does not found. "
+ f"original text: {result['log_message']}")
+ lat = float(result.group(1))
+ lon = float(result.group(2))
+ pe = gutils.calculate_position_error(lat, lon,
+ self.pixel_lab_location)
+ position_errors.append(pe)
+ self.ad.log.info("TestResult max_position_error %.2f" %
+ max(position_errors))
+
+ # Concurrency Test Cases
+ @test_tracker_info(uuid="9b0daebf-461e-4005-9773-d5d10aaeaaa4")
def test_gnss_concurrency_ct1(self):
test_duration = 15
criteria = {"ap_location": 1, "gnss": 1, "gnss_meas": 1}
- self.execute_gnss_concurrency_test(criteria, test_duration)
+ self.run_gnss_concurrency_test(criteria, test_duration)
+ @test_tracker_info(uuid="f423db2f-12a0-4858-b66f-99e7ca6010c3")
def test_gnss_concurrency_ct2(self):
test_duration = 30
criteria = {"ap_location": 1, "gnss": 8, "gnss_meas": 8}
- self.execute_gnss_concurrency_test(criteria, test_duration)
+ self.run_gnss_concurrency_test(criteria, test_duration)
+ @test_tracker_info(uuid="f72d2df0-f70a-4a11-9f68-2a38f6974454")
def test_gnss_concurrency_ct3(self):
test_duration = 60
criteria = {"ap_location": 15, "gnss": 8, "gnss_meas": 8}
- self.execute_gnss_concurrency_test(criteria, test_duration)
+ self.run_gnss_concurrency_test(criteria, test_duration)
+ @test_tracker_info(uuid="8e5563fd-afcd-40d3-9392-7fc0d10f49da")
def test_gnss_concurrency_aoc1(self):
test_duration = 120
criteria = {"ap_location": 61, "gnss": 1, "gnss_meas": 1}
- self.execute_gnss_concurrency_test(criteria, test_duration)
+ self.run_gnss_concurrency_test(criteria, test_duration)
+ @test_tracker_info(uuid="fb258565-6ac8-4bf7-a554-01d63fc4ef54")
def test_gnss_concurrency_aoc2(self):
test_duration = 120
criteria = {"ap_location": 61, "gnss": 10, "gnss_meas": 10}
- self.execute_gnss_concurrency_test(criteria, test_duration)
+ 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):
+ 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):
+ 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
+ }]
+ for interval in intervals:
+ self.run_chre_only_test(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()
+ self.ad.droid.startLocating(interval * 1000, 0)
+ time.sleep(test_duration)
+ self.ad.droid.stopLocating()
+ criteria = interval if interval > 1 else 1
+ 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)
diff --git a/acts_tests/tests/google/gnss/GnssFunctionTest.py b/acts_tests/tests/google/gnss/GnssFunctionTest.py
index 706acca..d45a997 100644
--- a/acts_tests/tests/google/gnss/GnssFunctionTest.py
+++ b/acts_tests/tests/google/gnss/GnssFunctionTest.py
@@ -19,7 +19,6 @@
import fnmatch
from multiprocessing import Process
-from acts import utils
from acts import asserts
from acts import signals
from acts.base_test import BaseTestClass
@@ -29,18 +28,13 @@
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
-from acts.utils import force_airplane_mode
from acts_contrib.test_utils.wifi.wifi_test_utils import wifi_toggle_state
-from acts_contrib.test_utils.tel.tel_test_utils import flash_radio
+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 abort_all_tests
-from acts_contrib.test_utils.tel.tel_test_utils import stop_qxdm_logger
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_voice_utils import hangup_call
-from acts_contrib.test_utils.tel.tel_test_utils import http_file_download_by_sl4a
-from acts_contrib.test_utils.tel.tel_test_utils import start_qxdm_logger
-from acts_contrib.test_utils.tel.tel_test_utils import trigger_modem_crash
+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
@@ -63,7 +57,6 @@
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_adb
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
@@ -73,9 +66,13 @@
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.tel.tel_test_utils import start_adb_tcpdump
-from acts_contrib.test_utils.tel.tel_test_utils import stop_adb_tcpdump
-from acts_contrib.test_utils.tel.tel_test_utils import get_tcpdump_log
+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.tel.tel_logging_utils import stop_adb_tcpdump
+from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log
class GnssFunctionTest(BaseTestClass):
@@ -94,13 +91,14 @@
"weak_signal_xtra_cs_criteria",
"weak_signal_xtra_ws_criteria",
"weak_signal_xtra_hs_criteria",
+ "wearable_reboot_hs_criteria",
"default_gnss_signal_attenuation",
"weak_gnss_signal_attenuation",
"no_gnss_signal_attenuation", "gnss_init_error_list",
"gnss_init_error_allowlist", "pixel_lab_location",
- "legacy_wifi_xtra_cs_criteria", "legacy_projects",
"qdsp6m_path", "supl_capabilities", "ttff_test_cycle",
- "collect_logs", "dpo_threshold"]
+ "collect_logs", "dpo_threshold",
+ "brcm_error_log_allowlist"]
self.unpack_userparams(req_param_names=req_params)
# create hashmap for SSID
self.ssid_map = {}
@@ -109,11 +107,8 @@
self.ssid_map[SSID] = network
self.ttff_mode = {"cs": "Cold Start",
"ws": "Warm Start",
- "hs": "Hot Start"}
- if self.ad.model in self.legacy_projects:
- self.wifi_xtra_cs_criteria = self.legacy_wifi_xtra_cs_criteria
- else:
- self.wifi_xtra_cs_criteria = self.xtra_cs_criteria
+ "hs": "Hot Start",
+ "csa": "CSWith Assist"}
if self.collect_logs and \
gutils.check_chipset_vendor_by_qualcomm(self.ad):
self.flash_new_radio_or_mbn()
@@ -126,6 +121,11 @@
clear_logd_gnss_qxdm_log(self.ad)
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"]])
if not verify_internet_connection(self.ad.log, self.ad, retries=3,
expected_state=True):
raise signals.TestFailure("Fail to connect to LTE network.")
@@ -136,18 +136,23 @@
stop_adb_tcpdump(self.ad)
set_attenuator_gnss_signal(self.ad, self.attenuators,
self.default_gnss_signal_attenuation)
- if check_call_state_connected_by_adb(self.ad):
- hangup_call(self.ad.log, self.ad)
- if int(self.ad.adb.shell("settings get global airplane_mode_on")) != 0:
+ # TODO(chenstanley): sim structure issue
+ if not is_device_wearable(self.ad):
+ if check_call_state_connected_by_adb(self.ad):
+ hangup_call(self.ad.log, self.ad)
+ if self.ad.droid.connectivityCheckAirplaneMode():
self.ad.log.info("Force airplane mode off")
- force_airplane_mode(self.ad, False)
- if self.ad.droid.wifiCheckState():
+ self.ad.droid.connectivityToggleAirplaneMode(False)
+ if not is_wearable_btwifi and self.ad.droid.wifiCheckState():
wifi_toggle_state(self.ad, False)
- if int(self.ad.adb.shell("settings get global mobile_data")) != 1:
+ if not is_mobile_data_on(self.ad):
set_mobile_data(self.ad, True)
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.")
def on_fail(self, test_name, begin_time):
if self.collect_logs:
@@ -287,7 +292,7 @@
"""
self.start_qxdm_and_tcpdump_log()
self.ad.log.info("Turn airplane mode on")
- force_airplane_mode(self.ad, True)
+ self.ad.droid.connectivityToggleAirplaneMode(True)
self.run_ttff_via_gtw_gpstool(mode, criteria)
def supl_ttff_weak_gnss_signal(self, mode, criteria):
@@ -337,12 +342,37 @@
disable_supl_mode(self.ad)
self.start_qxdm_and_tcpdump_log()
self.ad.log.info("Turn airplane mode on")
- force_airplane_mode(self.ad, True)
+ 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))
+
""" Test Cases """
@test_tracker_info(uuid="ab859f2a-2c95-4d15-bb7f-bd0e3278340f")
@@ -383,26 +413,14 @@
type="gnss",
testtime=tracking_minutes,
meas_flag=True)
- dpo_results = self.ad.search_logcat("HardwareClockDiscontinuityCount",
- dpo_begin_time)
- if not dpo_results:
- raise signals.TestError(
- "No \"HardwareClockDiscontinuityCount\" is found in logs.")
- self.ad.log.info(dpo_results[0]["log_message"])
- self.ad.log.info(dpo_results[-1]["log_message"])
- first_dpo_count = int(dpo_results[0]["log_message"].split()[-1])
- final_dpo_count = int(dpo_results[-1]["log_message"].split()[-1])
- dpo_rate = ((final_dpo_count - first_dpo_count)/(tracking_minutes * 60))
- dpo_engage_rate = "{percent:.2%}".format(percent=dpo_rate)
- self.ad.log.info("DPO is ON for %d seconds during %d minutes test." % (
- final_dpo_count - first_dpo_count, tracking_minutes))
- self.ad.log.info("TestResult DPO_Engage_Rate " + dpo_engage_rate)
- threshold = "{percent:.0%}".format(percent=self.dpo_threshold / 100)
- asserts.assert_true(dpo_rate * 100 > self.dpo_threshold,
- "DPO only engaged %s in %d minutes test with "
- "threshold %s." % (dpo_engage_rate,
- tracking_minutes,
- threshold))
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ gutils.check_dpo_rate_via_gnss_meas(self.ad,
+ dpo_begin_time,
+ self.dpo_threshold)
+ else:
+ gutils.check_dpo_rate_via_brcm_log(self.ad,
+ self.dpo_threshold,
+ self.brcm_error_log_allowlist)
@test_tracker_info(uuid="499d2091-640a-4735-9c58-de67370e4421")
def test_gnss_init_error(self):
@@ -936,7 +954,7 @@
All SUPL TTFF Cold Start results should be within supl_cs_criteria.
"""
for times in range(1, 4):
- fastboot_factory_reset(self.ad)
+ fastboot_factory_reset(self.ad, True)
self.ad.unlock_screen(password=None)
_init_device(self.ad)
begin_time = get_current_epoch_time()
@@ -1052,9 +1070,9 @@
Expected Results:
XTRA/LTO TTFF Cold Start results should be within
- wifi_xtra_cs_criteria.
+ xtra_cs_criteria.
"""
- self.xtra_ttff_wifi("cs", self.wifi_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):
@@ -1171,7 +1189,7 @@
disable_supl_mode(self.ad)
self.start_qxdm_and_tcpdump_log()
self.ad.log.info("Turn airplane mode on")
- force_airplane_mode(self.ad, True)
+ 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"]])
@@ -1283,12 +1301,80 @@
start_gnss_by_gtw_gpstool(self.ad, False)
for test_loop in range(1, 11):
reboot(self.ad)
- test_result = process_gnss_by_gtw_gpstool(
- self.ad, self.supl_hs_criteria, clear_data=False)
+ self.start_qxdm_and_tcpdump_log()
+ if is_device_wearable(self.ad):
+ test_result = process_gnss_by_gtw_gpstool(
+ self.ad, self.wearable_reboot_hs_criteria, clear_data=False)
+ else:
+ test_result = process_gnss_by_gtw_gpstool(
+ self.ad, self.supl_hs_criteria, clear_data=False)
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)
+ gutils.stop_pixel_logger(self.ad)
+ stop_adb_tcpdump(self.ad)
pass_rate = overall_test_result.count(True)/len(overall_test_result)
self.ad.log.info("TestResult Pass_rate %s" % format(pass_rate, ".0%"))
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.
+
+ 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 = []
+ 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.")
+
+ @test_tracker_info(uuid="a7048a4f-8a40-40a4-bb6c-7fc90e8227bd")
+ def test_ws_with_assist(self):
+ """Verify Warm Start functionality with existed LTO data.
+
+ 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.
+
+ Expected Results:
+ All TTFF Warm Start with Assist results should be within
+ xtra_ws_criteria.
+ """
+ self.ttff_with_assist("ws", self.xtra_ws_criteria)
+
+ @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.
+ """
+ self.ttff_with_assist("csa", self.standalone_cs_criteria)
diff --git a/acts_tests/tests/google/gnss/GnssHsSenTest.py b/acts_tests/tests/google/gnss/GnssHsSenTest.py
new file mode 100644
index 0000000..5269ae0
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssHsSenTest.py
@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+#
+# 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 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
+
+
+class GnssHsSenTest(GnssBlankingBase):
+ """ LAB GNSS Cellular coex hot start sensitivity search"""
+
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.gnss_simulator_power_level = -130
+ self.sa_sensitivity = -150
+ self.gnss_pwr_lvl_offset = 5
+
+ def gnss_hot_start_sensitivity_search_base(self, cellular_enable=False):
+ """
+ Perform GNSS hot start sensitivity search.
+
+ Args:
+ cellular_enable: argument to identify if Tx cellular signal is required or not.
+ Type, bool.
+ Default, False.
+ """
+ # 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)
+ # 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)
+
+ def test_hot_start_sensitivity_search(self):
+ """
+ GNSS hot start stand alone sensitivity search.
+ """
+ self.gnss_hot_start_sensitivity_search_base(False)
+
+ def test_hot_start_sensitivity_search_gsm850(self):
+ """
+ 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.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.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.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.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.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.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.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.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.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.gnss_hot_start_sensitivity_search_base(True)
diff --git a/acts_tests/tests/google/gnss/GnssPowerAGPSTest.py b/acts_tests/tests/google/gnss/GnssPowerAGPSTest.py
index df52d64..15ec3c2 100644
--- a/acts_tests/tests/google/gnss/GnssPowerAGPSTest.py
+++ b/acts_tests/tests/google/gnss/GnssPowerAGPSTest.py
@@ -36,16 +36,17 @@
self.set_cell_only()
self.start_gnss_tracking_with_power_data()
- def test_cell_strong_cn_long(self):
- self.set_cell_only()
- self.start_gnss_tracking_with_power_data()
-
- def test_cell_weak_cn_long(self):
- self.set_attenuation(self.atten_level['weak_signal'])
- self.set_cell_only()
- self.start_gnss_tracking_with_power_data()
-
def test_cell_no_signal(self):
self.set_attenuation(self.atten_level['no_signal'])
self.set_cell_only()
self.start_gnss_tracking_with_power_data(is_signal=False)
+
+ # Long Interval tests
+ def test_cell_strong_cn_long(self):
+ self.set_cell_only()
+ self.start_gnss_tracking_with_power_data(freq=self.interval)
+
+ def test_cell_weak_cn_long(self):
+ self.set_attenuation(self.atten_level['weak_signal'])
+ self.set_cell_only()
+ self.start_gnss_tracking_with_power_data(freq=self.interval)
diff --git a/acts_tests/tests/google/gnss/GnssPowerBasicTest.py b/acts_tests/tests/google/gnss/GnssPowerBasicTest.py
index b74aa96..d4ee545 100644
--- a/acts_tests/tests/google/gnss/GnssPowerBasicTest.py
+++ b/acts_tests/tests/google/gnss/GnssPowerBasicTest.py
@@ -46,7 +46,7 @@
self.start_gnss_tracking_with_power_data()
# Long Interval tests
- def test_standalone_DPO_long_strong_cn(self):
+ def test_standalone_DPO_strong_cn_long(self):
self.start_gnss_tracking_with_power_data(freq=self.interval)
def test_standalone_NDPO_strong_cn_long(self):
diff --git a/acts_tests/tests/google/gnss/GnssPowerFrequecyTest.py b/acts_tests/tests/google/gnss/GnssPowerFrequecyTest.py
new file mode 100644
index 0000000..e24845e
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssPowerFrequecyTest.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+#
+# 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.
+
+from acts import utils
+from acts_contrib.test_utils.power.PowerGTWGnssBaseTest import PowerGTWGnssBaseTest
+
+
+class GnssPowerFrequencyTest(PowerGTWGnssBaseTest):
+ """Gnss Power Low Power Mode Test"""
+
+ # Test cases
+ # L1 only test cases
+ def test_L1_only_strong(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1_strong_signal'])
+ self.start_gnss_tracking_with_power_data()
+
+ def test_L1_only_weak(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1_weak_signal'])
+ self.start_gnss_tracking_with_power_data()
+
+ # L5 tests
+ def test_L1L5_strong(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1l5_strong_signal'])
+ self.start_gnss_tracking_with_power_data()
+
+ def test_L1L5_weak(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1l5_weak_signal'])
+ self.start_gnss_tracking_with_power_data()
+
+ def test_L1_weak_L5_strong(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1_w_l5_s_signal'])
+ self.start_gnss_tracking_with_power_data()
+
+ def test_L1_strong_L5_weak(self):
+ self.ad.adb.shell('settings put secure location_mode 3')
+ self.set_attenuation(self.atten_level['l1_s_l5_w_signal'])
+ self.start_gnss_tracking_with_power_data()
diff --git a/acts_tests/tests/google/gnss/GnssPowerMeasurementTest.py b/acts_tests/tests/google/gnss/GnssPowerMeasurementTest.py
index 3125263..affd322 100644
--- a/acts_tests/tests/google/gnss/GnssPowerMeasurementTest.py
+++ b/acts_tests/tests/google/gnss/GnssPowerMeasurementTest.py
@@ -31,6 +31,7 @@
self.start_gnss_tracking_with_power_data(
mode='standalone', freq=self.meas_interval, meas=True)
+ # Long Interval tests
def test_measurement_DPO_long(self):
self.start_gnss_tracking_with_power_data(
mode='standalone', freq=self.interval, meas=True)
diff --git a/acts_tests/tests/google/gnss/GnssSimInventoryTest.py b/acts_tests/tests/google/gnss/GnssSimInventoryTest.py
index cabd82d..801aa85 100644
--- a/acts_tests/tests/google/gnss/GnssSimInventoryTest.py
+++ b/acts_tests/tests/google/gnss/GnssSimInventoryTest.py
@@ -1,6 +1,6 @@
import time
import os
-import tempfile
+import re
from acts import utils
from acts import signals
@@ -15,8 +15,6 @@
def setup_class(self):
super().setup_class()
self.ad = self.android_devices[0]
- req_params = ["sim_inventory_recipient", "sim_inventory_ldap"]
- self.unpack_userparams(req_param_names=req_params)
def check_device_status(self):
if int(self.ad.adb.shell("settings get global airplane_mode_on")) != 0:
@@ -27,34 +25,32 @@
def get_imsi(self):
self.ad.log.info("Get imsi from netpolicy.xml")
- tmp_path = tempfile.mkdtemp()
- self.ad.pull_files("/data/system/netpolicy.xml", tmp_path)
- netpolicy_path = os.path.join(tmp_path, "netpolicy.xml")
- with open(netpolicy_path, "r", encoding="utf-8") as file:
- for line in file.readlines():
- if "subscriberId" in line:
- imsi = line.split(" ")[2].split("=")[-1].strip('"')
- return imsi
- raise signals.TestFailure("Fail to get imsi")
+ try:
+ tmp_imsi = self.ad.adb.shell("cat /data/system/netpolicy.xml")
+ imsi = re.compile(r'(\d{15})').search(tmp_imsi).group(1)
+ return imsi
+ except Exception as e:
+ raise signals.TestFailure("Fail to get imsi : %s" % e)
def get_iccid(self):
iccid = str(get_iccid_by_adb(self.ad))
if not isinstance(iccid, int):
self.ad.log.info("Unable to get iccid via adb. Changed to isub.")
- iccid = str(self.ad.adb.shell(
- "dumpsys isub | grep iccid")).split(" ")[4].strip(",")
+ tmp_iccid = self.ad.adb.shell("dumpsys isub | grep iccid")
+ iccid = re.compile(r'(\d{20})').search(tmp_iccid).group(1)
return iccid
raise signals.TestFailure("Fail to get iccid")
def test_gnss_sim_inventory(self):
+ sim_inventory_recipient = "0958787507"
self.check_device_status()
sms_message = "imsi: %s, iccid: %s, ldap: %s, model: %s, sn: %s" % (
- self.get_imsi(), self.get_iccid(), self.sim_inventory_ldap,
- self.ad.model, self.ad.serial)
+ self.get_imsi(), self.get_iccid(), os.getlogin(), self.ad.model,
+ self.ad.serial)
self.ad.log.info(sms_message)
try:
self.ad.log.info("Send SMS by SL4A.")
- self.ad.droid.smsSendTextMessage(self.sim_inventory_recipient,
+ self.ad.droid.smsSendTextMessage(sim_inventory_recipient,
sms_message, True)
self.ad.ed.pop_event(EventSmsSentSuccess, 10)
except Exception as e:
diff --git a/acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py b/acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py
new file mode 100644
index 0000000..9f3ccfd
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssUserBuildBroadcomConfigurationTest.py
@@ -0,0 +1,419 @@
+"""Make sure the user build configuration is working as expected.
+
+Although we can assume the features should be the same between user and user_debug build,
+the configuration difference between this two build are not tested.
+
+In this test suite, we modify the gps configuration to be the same as user build
+and check if the setting is working.
+For more details, please refer to : go/p22_user_build_verification
+"""
+import os
+import shutil
+import tempfile
+import time
+
+from acts import asserts
+from acts import signals
+from acts.base_test import BaseTestClass
+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.gnss import gnss_test_utils as gutils
+
+
+class GpsConfig:
+ def __init__(self, ad, name) -> None:
+ self.ad = ad
+ self.name = name
+ self.folder = "/vendor/etc/gnss"
+ self.full_path = os.path.join(self.folder, self.name)
+ self.logenabled = "LogEnabled"
+ self._log_enable = "true"
+ self._log_disable = "false"
+
+ def _change_file_content(self, pattern, target):
+ """Modify file via sed command
+
+ command will be sed -i 's/<pattern>/<target>/g' <file_path>
+ Args:
+ pattern: a string will be used as search pattern
+ target: string that will overwrite the matched result
+ """
+ self.ad.adb.remount()
+ command = f"sed -i s/{pattern}/{target}/g {self.full_path}"
+ self.ad.adb.shell(command)
+
+ def _get_setting_value(self, key):
+ """Get setting value from config file
+
+ command is grep <key> self.full_path
+ Args:
+ key: a string will be used as search pattern
+ Returns:
+ string: grep result ("" for no grep result)
+ """
+ command = f"grep {key} {self.full_path}"
+ result = self.ad.adb.shell(command)
+ return result
+
+ def _adjust_log_enable_setting(self, key, enable):
+ """Enable / Disable in self.full_path by setting key = true / false
+ Args:
+ key: The target will be changed
+ enable: True to enable / False to disable
+ """
+ src = self._log_disable if enable else self._log_enable
+ target = self._log_enable if enable else self._log_disable
+ pattern = f"{key}={src}"
+ target = f"{key}={target}"
+ self._change_file_content(pattern, target)
+ result = self._get_setting_value(key)
+ self.ad.log.debug("%s setting: %s", self.name, result)
+
+ def _check_file_exist(self, file_pattern):
+ """use command ls to check if file/dir exists
+ command ls <file_pattern>
+ Args:
+ file_pattern: A string represents the file or dir
+ Returns:
+ bool: True -> file exists / False -> file doesn't exist
+ """
+ command = f"ls {file_pattern}"
+ try:
+ self.ad.adb.shell(command)
+ result = True
+ except AdbCommandError as e:
+ result = False
+ return result
+
+ def enable_diagnostic_log(self):
+ """Set LogEnabled=true in config file
+ In gps.xml it will be LogEnabled=\"true\"
+ """
+ self.ad.log.info("Enable diagnostic log in %s", self.name)
+ self._adjust_log_enable_setting(key=self.logenabled, enable=True)
+
+ def disable_diagnostic_log(self):
+ """Set LogEnabled=false in config file
+ In gps.xml it will be LogEnabled=\"false\"
+ """
+ self.ad.log.info("Disable diagnostic log in %s", self.name)
+ self._adjust_log_enable_setting(key=self.logenabled, enable=False)
+
+
+class ScdConf(GpsConfig):
+ def __init__(self, ad) -> None:
+ super().__init__(ad, "scd.conf")
+
+
+class GpsXml(GpsConfig):
+ def __init__(self, ad) -> None:
+ super().__init__(ad, "gps.xml")
+ self.supllogenable = "SuplLogEnable"
+ self.supl_log = "/data/vendor/gps/suplflow.txt"
+ self._log_enable = "\\\"true\\\""
+ self._log_disable = "\\\"false\\\""
+
+ def enable_supl_log(self):
+ """Set SuplLogEnable=\"true\" in gps.xml"""
+ self.ad.log.info("Enable SUPL logs")
+ self._adjust_log_enable_setting(key=self.supllogenable, enable=True)
+
+ def disable_supl_log(self):
+ """Set SuplLogEnable=\"false\" in gps.xml"""
+ self.ad.log.info("Disable SUPL log")
+ self._adjust_log_enable_setting(key=self.supllogenable, enable=False)
+
+ def remove_supl_logs(self):
+ """Remove /data/vendor/gps/suplflow.txt"""
+ self.ad.log.info("Remove SUPL logs")
+ command = f"rm -f {self.supl_log}"
+ self.ad.adb.shell(command)
+
+ def is_supl_log_file_exist(self):
+ """Check if /data/vendor/gps/suplflow.txt exist
+ Returns:
+ bool: True -> supl log exists / False -> supl log doesn't exist
+ """
+ result = self._check_file_exist(self.supl_log)
+ self.ad.log.debug("Supl file exists?: %s", result)
+ return result
+
+
+class LhdConf(GpsConfig):
+ def __init__(self, ad) -> None:
+ super().__init__(ad, "lhd.conf")
+ self.lhefailsafe = "LheFailSafe"
+ 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.
+ Enable - uncomment out the setting
+ Dissable - comment out the setting
+ Args:
+ key: A string will be used as search pattern
+ enable: bool True to enable / False to disable
+ """
+ pattern = f"#\ {key}" if enable else key
+ target = key if enable else f"#\ {key}"
+ self._change_file_content(pattern, target)
+
+ def enable_lhefailsafe(self):
+ """Uncomment out LheFailSafe"""
+ self.ad.log.info("Enable %s", self.lhefailsafe)
+ self._adjust_lhe_setting(key=self.lhefailsafe, enable=True)
+
+ def disable_lhefailsafe(self):
+ """Comment out LheFailSafe"""
+ self.ad.log.info("Disable %s", self.lhefailsafe)
+ self._adjust_lhe_setting(key=self.lhefailsafe, enable=False)
+
+ def enable_lheconsole(self):
+ """Uncomment out LheConsole"""
+ self.ad.log.info("Enable %s", self.lheconsole)
+ self._adjust_lhe_setting(key=self.lheconsole, enable=True)
+
+ def disable_lheconsole(self):
+ """Comment out LheConsole"""
+ self.ad.log.info("Disable %s", self.lheconsole)
+ self._adjust_lhe_setting(key=self.lheconsole, enable=False)
+
+ def get_lhefailsafe_value(self):
+ """Get the LheFailSafe value
+
+ Returns:
+ string: the LheFailSafe value in config
+ Raises:
+ ValueError: No LheFailSafe value
+ """
+ result = self._get_setting_value(self.lhefailsafe)
+ if not result:
+ raise ValueError(("%s should exists in %s", self.lhefailsafe, self.name))
+ result = result.split("=")[1]
+ self.ad.log.debug("%s is %s", self.lhefailsafe, result)
+ return result
+
+ def get_lheconsole_value(self):
+ """Get the LheConsole value
+
+ Returns:
+ string: the LheConsole value in config
+ Raises:
+ ValueError: No LheConsole value
+ """
+ result = self._get_setting_value(self.lheconsole)
+ if not result:
+ raise ValueError(("%s should exists in %s", self.lheconsole, self.name))
+ result = result.split("=")[1]
+ self.ad.log.debug("%s is %s", self.lheconsole, result)
+ return result
+
+ def get_esw_crash_dump_pattern(self):
+ """Get the esw crash dump file pattern
+ The value is set in LheFailSafe, but we need to add wildcard.
+ Returns:
+ string: esw crash dump pattern
+ Raises:
+ ValueError: No LheFailSafe value
+ """
+ value = self.get_lhefailsafe_value()
+ value = value.replace(".txt", "*.txt")
+ self.ad.log.debug("Dump file pattern is %s", value)
+ return value
+
+ def remove_esw_crash_dump_file(self):
+ """Remove crash dump file"""
+ self.ad.log.info("Remove esw crash file")
+ command = f"rm -f {self.esw_crash_dump_pattern}"
+ self.ad.adb.shell(command)
+
+ def trigger_firmware_crash(self):
+ """Send command to LheConsole to trigger firmware crash"""
+ self.ad.log.info("Trigger firmware crash")
+ command = f"echo Lhe:write=0xFFFFFFFF,4 > {self.lheconsole_hub}.toAsic"
+ self.ad.adb.shell(command, timeout=10)
+
+ def is_esw_crash_dump_file_exist(self):
+ """Check if esw_crash_dump_pattern exists
+ Will try 3 times, 1 second interval for each attempt
+ Returns:
+ bool: True -> file exists / False -> file doesn't exist
+ """
+ for attempt in range(1, 4):
+ result = self._check_file_exist(self.esw_crash_dump_pattern)
+ self.ad.log.debug("(Attempt %s)esw dump file exists?: %s", attempt, result)
+ if result:
+ return result
+ time.sleep(1)
+ return False
+
+
+class GnssUserBuildBroadcomConfigurationTest(BaseTestClass):
+ """ GNSS user build configuration Tests on Broadcom device."""
+ def setup_class(self):
+ super().setup_class()
+ self.ad = self.android_devices[0]
+
+ if not gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ gutils._init_device(self.ad)
+ self.gps_config_path = tempfile.mkdtemp()
+ self.gps_xml = GpsXml(self.ad)
+ self.lhd_conf = LhdConf(self.ad)
+ self.scd_conf = ScdConf(self.ad)
+ self.enable_testing_setting()
+ self.backup_gps_config()
+
+ 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):
+ if gutils.check_chipset_vendor_by_qualcomm(self.ad):
+ raise signals.TestSkip("Device is Qualcomm, skip the test")
+ 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()
+
+ def on_fail(self, test_name, begin_time):
+ self.ad.take_bug_report(test_name, begin_time)
+ gutils.get_gnss_qxdm_log(self.ad)
+
+ def enable_testing_setting(self):
+ """Enable setting to the testing target
+ Before backing up config, enable all the testing target
+ To ensure the teardown_test can bring the device back to the desired state
+ """
+ self.set_gps_logenabled(enable=True)
+ self.gps_xml.enable_supl_log()
+ self.lhd_conf.enable_lheconsole()
+ self.lhd_conf.enable_lhefailsafe()
+
+ def backup_gps_config(self):
+ """Copy the gps config
+
+ config file will be copied: gps.xml / lhd.conf / scd.conf
+ """
+ for conf in [self.gps_xml, self.scd_conf, self.lhd_conf]:
+ self.ad.log.debug("Backup %s", conf.full_path)
+ self.ad.adb.pull(conf.full_path, self.gps_config_path)
+
+ def revert_gps_config(self):
+ """Revert the gps config from the one we backup in the setup_class
+
+ config file will be reverted: gps.xml / lhd.conf / scd.conf
+ """
+ self.ad.adb.remount()
+ for conf in [self.gps_xml, self.scd_conf, self.lhd_conf]:
+ file_path = os.path.join(self.gps_config_path, conf.name)
+ self.ad.log.debug("Revert %s", conf.full_path)
+ self.ad.adb.push(file_path, conf.full_path)
+
+ 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)
+
+ def set_gps_logenabled(self, enable):
+ """Set LogEnabled in gps.xml / lhd.conf / scd.conf
+
+ Args:
+ enable: True to enable / False to disable
+ """
+ if enable:
+ self.gps_xml.enable_diagnostic_log()
+ self.scd_conf.enable_diagnostic_log()
+ self.lhd_conf.enable_diagnostic_log()
+ else:
+ self.gps_xml.disable_diagnostic_log()
+ 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
+ 4. disable LogEnabled in all the gps conf
+ 5. enable gps for 15s
+ 6. assert gps log pattern "slog :" in pixel logger
+ """
+ self.run_gps_and_capture_log()
+ result, _ = gutils.parse_brcm_nmea_log(self.ad, "slog :", [])
+ 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)
+
+ 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)))
+
+ @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
+ 4. supl log should exist
+ 5. disable SuplLogEnable in gps.xml
+ 6. remove existing supl log
+ 7. enable gps for 15s
+ 8. supl log should not exist
+ """
+ def is_supl_log_exist_after_supl_request():
+ self.gps_xml.remove_supl_logs()
+ self.run_gps_and_capture_log()
+ return self.gps_xml.is_supl_log_file_exist()
+
+ result = is_supl_log_exist_after_supl_request()
+ 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:
+ 1. both setting is enabled
+ 2. trigger firmware crash and check if dump file exist
+ 3. disable lhefailsafe
+ 4. trigger firmware crash and check if dump file exist
+ 5. disable lheconsle
+ 6. trigger firmware crash and check if command timeout
+ """
+ def is_dump_file_exist_after_firmware_crash():
+ self.lhd_conf.remove_esw_crash_dump_file()
+ self.lhd_conf.trigger_firmware_crash()
+ return self.lhd_conf.is_esw_crash_dump_file_exist()
+
+ result = is_dump_file_exist_after_firmware_crash()
+ asserts.assert_true(result, "LheFailSafe is enabled, but no crash file was found")
+
+ self.lhd_conf.disable_lhefailsafe()
+ self.ad.reboot()
+
+ result = is_dump_file_exist_after_firmware_crash()
+ asserts.assert_false(result, "LheFailSafe is disabled, but still found crash file")
+
+ self.lhd_conf.disable_lheconsole()
+ self.ad.reboot()
+
+ with asserts.assert_raises(TimeoutError):
+ self.lhd_conf.trigger_firmware_crash()
diff --git a/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py b/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py
new file mode 100644
index 0000000..87a233d
--- /dev/null
+++ b/acts_tests/tests/google/gnss/GnssWearableTetherFunctionTest.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+#
+# Copyright 2020 - The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import time
+import os
+
+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 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.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
+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 check_tracking_file
+from uiautomator import Device
+
+
+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" ]
+ 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"}
+ gutils._init_device(self.watch)
+ pair_to_wearable(self.watch, self.phone)
+
+ def setup_test(self):
+ 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)
+
+ 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)
+
+ def on_fail(self, test_name, begin_time):
+ self.watch.take_bug_report(test_name, begin_time)
+ gutils.get_gnss_qxdm_log(self.watch)
+ tutils.get_tcpdump_log(self.watch, test_name, begin_time)
+
+ def start_qxdm_and_tcpdump_log(self):
+ """Start QXDM and adb tcpdump if collect_logs is True."""
+ gutils.start_pixel_logger(self.watch)
+ tutils.start_adb_tcpdump(self.watch)
+
+ def flp_ttff(self, mode, criteria, location):
+ self.start_qxdm_and_tcpdump_log()
+ start_gnss_by_gtw_gpstool(self.phone, True, 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")
+ gutils.check_ttff_data(self.watch, results, mode, criteria)
+ self.check_location_from_phone()
+ start_gnss_by_gtw_gpstool(self.phone, False, 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)
+
+ """ 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.
+
+ Steps:
+ 1. Pair with phone via Bluetooth.
+ 2. FLP TTFF Cold Start for 10 iteration.
+ 3. Check location source is from Phone.
+
+ Expected Results:
+ 1. FLP TTFF Cold Start results should be within
+ flp_ttff_max_threshold.
+ 2. Watch uses phone's FLP 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.
+
+ Steps:
+ 1. Pair with phone via Bluetooth.
+ 2. FLP TTFF Warm Start for 10 iteration.
+ 3. Check location source is from Phone.
+
+ Expected Results:
+ 1. FLP TTFF Warm Start results should be within
+ flp_ttff_max_threshold.
+ 2. Watch uses phone's FLP 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.
+
+ Steps:
+ 1. Pair with phone via Bluetooth.
+ 2. FLP TTFF Hot Start for 10 iteration.
+ 3. Check location source is from Phone.
+
+ Expected Results:
+ 1. FLP TTFF Hot Start results should be within
+ flp_ttff_max_threshold.
+ 2. Watch uses phone's FLP 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.
+
+ Steps:
+ 1. Make sure watch Bluetooth is on and in paired status.
+ 2. Do 1 min tracking.
+ 3. After 1 min tracking, check location source is using phone's FLP.
+ 4. Turn off watch Bluetooth, and do 1 min tracking.
+ 5. After 1 min tracking, check tracking results.
+ 6. Repeat Step 1 to Step 5 for 5 times.
+
+ Expected Results:
+ 1. Watch uses phone's FLP location in Bluetooth connect state.
+ 2. Tracking results should be within pixel_lab_location criteria.
+ """
+ self.start_qxdm_and_tcpdump_log()
+ for i in range(1, 6):
+ 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")
+ time.sleep(self.flp_waiting_time)
+ start_gnss_by_gtw_gpstool(self.watch, True, type="FLP")
+ time.sleep(self.flp_waiting_time)
+ self.watch.log.info("Wait 1 min for tracking")
+ time.sleep(self.tracking_test_time)
+ if not self.check_location_from_phone():
+ raise signals.TestFailure("Watch is not using phone location")
+ self.watch.droid.bluetoothToggleState(False)
+ self.watch.log.info("Turn off Watch Bluetooth")
+ self.watch.log.info("Wait 1 min for tracking")
+ 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")
+
+ @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
+
+ 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. 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.
+ """
+ for i in range(1,6):
+ self.watch.log.info("First fix of Fast Start - 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")
diff --git a/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py b/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py
new file mode 100644
index 0000000..24da4d3
--- /dev/null
+++ b/acts_tests/tests/google/gnss/LabTtffGeneralCoexTest.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+#
+# 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.
+
+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
+
+
+class LabTtffGeneralCoexTest(lttb.LabTtffTestBase):
+ """Lab stand alone GNSS general coex TTFF/FFPE test"""
+
+ def setup_class(self):
+ super().setup_class()
+ req_params = ['coex_testcase_ls']
+ self.unpack_userparams(req_param_names=req_params)
+
+ def setup_test(self):
+ super().setup_test()
+ launch_eecoexer(self.dut)
+ # Set DUT temperature the limit to 60 degree
+ 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 gnss_ttff_ffpe_coex_base(self, mode):
+ """
+ TTFF and FFPE general coex base test function
+
+ Args:
+ mode: Set the TTFF mode for testing. Definitions are as below.
+ 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:
+
+ # 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']
+
+ # get stop_cmd from coex_testcase_ls['stop_cmd']
+ stop_cmd = test_item['stop_cmd']
+
+ # Start aggressor Tx by EEcoexer
+ self.exe_eecoexer_loop_cmd(test_cmd)
+
+ # Start GNSS TTFF FFPE testing
+ self.gnss_ttff_ffpe(mode, test_log_path)
+
+ # Stop aggressor Tx by EEcoexer
+ 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()
+
+ def test_gnss_cold_ttff_ffpe_coex(self):
+ """
+ Cold start TTFF and FFPE GNSS general coex testing
+ """
+ self.gnss_ttff_ffpe_coex_base('cs')
+
+ def test_gnss_warm_ttff_ffpe_coex(self):
+ """
+ Warm start TTFF and FFPE GNSS general coex testing
+ """
+ self.gnss_ttff_ffpe_coex_base('ws')
+
+ def test_gnss_hot_ttff_ffpe_coex(self):
+ """
+ Hot start TTFF and FFPE GNSS general coex testing
+ """
+ self.gnss_ttff_ffpe_coex_base('hs')
diff --git a/acts_tests/tests/google/gnss/LabTtffTest.py b/acts_tests/tests/google/gnss/LabTtffTest.py
index 5c05fa9..374b570 100644
--- a/acts_tests/tests/google/gnss/LabTtffTest.py
+++ b/acts_tests/tests/google/gnss/LabTtffTest.py
@@ -14,284 +14,29 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os
-import time
-import glob
-import errno
+from acts_contrib.test_utils.gnss import LabTtffTestBase as lttb
-from acts import utils
-from acts import asserts
-from acts import signals
-from acts import base_test
-from pandas import DataFrame
-from collections import namedtuple
-from acts.controllers.spectracom_lib import gsg6
-from acts.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
-DEVICE_GPSLOG_FOLDER = '/sdcard/Android/data/com.android.gpstool/files/'
-GPS_PKG_NAME = 'com.android.gpstool'
-
-class LabTtffTest(base_test.BaseTestClass):
-
- """ LAB TTFF Tests"""
- GTW_GPSTOOL_APP = 'gtw_gpstool_apk'
- SPECTRACOM_IP_KEY = 'spectracom_ip'
- SPECTRACOM_PORT_KEY = 'spectracom_port'
- SPECTRACOM_FILES_KEY = 'spectracom_files'
- SPECTRACOM_POWER_KEY = 'spectracom_power_level'
- SPIRENT_IP_KEY = 'spirent_ip'
- SPIRENT_SCENARIO = 'sprient_scenario'
- CUSTOM_FILES_KEY = 'custom_files'
- CSTTFF_CRITERIA = 'cs_criteria'
- HSTTFF_CRITERIA = 'hs_criteria'
- WSTTFF_CRITERIA = 'ws_criteria'
- CSTTFF_PECRITERIA = 'cs_ttff_pecriteria'
- HSTTFF_PECRITERIA = 'hs_ttff_pecriteria'
- WSTTFF_PECRITERIA = 'ws_ttff_pecriteria'
- TTFF_ITERATION = 'ttff_iteration'
- SIMULATOR_LOCATION = 'simulator_location'
- DIAG_OPTION = 'diag_option'
-
- def __init__(self, controllers):
- """ Initializes class attributes. """
-
- super().__init__(controllers)
-
- self.dut = None
- self.spectracom = None
-
- def setup_class(self):
- super().setup_class()
-
- req_params = [
- self.SPECTRACOM_IP_KEY, self.SPECTRACOM_PORT_KEY,
- self.SPECTRACOM_FILES_KEY, self.SPECTRACOM_POWER_KEY,
- self.CSTTFF_CRITERIA, self.HSTTFF_CRITERIA,
- self.WSTTFF_CRITERIA, self.TTFF_ITERATION,
- self.SIMULATOR_LOCATION, self.DIAG_OPTION
- ]
-
- for param in req_params:
- if param not in self.user_params:
- self.log.error('Required parameter {} is missing in config '
- 'file.'.format(param))
- raise signals.TestAbortClass(
- 'Required parameter {} is missing in config '
- 'file.'.format(param))
- self.dut = self.android_devices[0]
- self.spectracom_ip = self.user_params[self.SPECTRACOM_IP_KEY]
- self.spectracom_port = self.user_params[self.SPECTRACOM_PORT_KEY]
- self.spectracom_file = self.user_params[self.SPECTRACOM_FILES_KEY]
- self.spectracom_power = self.user_params[self.SPECTRACOM_POWER_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, [])
-
- 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 or fail class setup if it can't be found
- for file in custom_files:
- if 'rockbottom_' + self.dut.model in file:
- self.rockbottom_script = file
- break
- else:
- raise signals.TestAbortClass(
- 'Required rockbottom script is missing.')
-
- def setup_test(self):
-
- self.clear_gps_log()
- self.spectracom = gsg6.GSG6(self.spectracom_ip, self.spectracom_port)
-
- self.spectracom.stop_scenario()
- time.sleep(10)
- self.spectracom.close()
-
- self.dut_rockbottom()
- utils.set_location_service(self.dut, True)
- gutils.reinstall_package_apk(self.dut, GPS_PKG_NAME,
- self.gtw_gpstool_app)
- self.spectracom = gsg6.GSG6(self.spectracom_ip, self.spectracom_port)
- self.spectracom.connect()
-
- def dut_rockbottom(self):
- """
- Set the dut to rockbottom state
-
- """
- # 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)
- os.chmod(self.rockbottom_script, 0o777)
- os.system('{} {}'.format(self.rockbottom_script, self.dut.serial))
- # Make sure the DUT is in root mode after coming back
- self.dut.root_adb()
- # Restart SL4A
- self.dut.start_services()
-
- def teardown_class(self):
- """ Executed after completing all selected test cases."""
- self.clear_gps_log()
- if self.spectracom:
- self.spectracom.stop_scenario()
- time.sleep(10)
- self.spectracom.close()
-
- def start_and_set_spectracom_power(self):
- """
- Start spectracom secnario and set power level.
-
- """
-
- self.spectracom.start_scenario(self.spectracom_file)
- time.sleep(25)
- self.spectracom.set_power(self.spectracom_power)
-
- def get_and_verify_ttff(self, mode):
- """Retrieve ttff with designate mode.
-
- Args:
- mode: A string for identify gnss test mode.
- """
- if mode not in self.test_types:
- raise signals.TestError('Unrecognized mode %s' % mode)
- test_type = self.test_types.get(mode)
-
- gutils.process_gnss_by_gtw_gpstool(self.dut,
- self.test_types['cs'].criteria)
- begin_time = gutils.get_current_epoch_time()
- gutils.start_ttff_by_gtw_gpstool(
- self.dut, ttff_mode=mode,
- iteration=self.ttff_iteration, aid_data=True)
- ttff_data = gutils.process_ttff_by_gtw_gpstool(self.dut, begin_time,
- self.simulator_location)
-
- gps_log_path = os.path.join(self.log_path, 'GPSLogs')
- self.dut.adb.pull("{} {}".format(DEVICE_GPSLOG_FOLDER, gps_log_path))
-
- gps_api_log = glob.glob(gps_log_path + '/GPS_API_*.txt')
- ttff_loop_log = glob.glob(gps_log_path + '/GPS_{}_*.txt'.
- format(mode.upper()))
-
- 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]))
-
- ttff_dict = {}
- for i in ttff_data:
- d = ttff_data[i]._asdict()
- ttff_dict[i] = dict(d)
-
- ttff_time =[]
- ttff_pe = []
- for i, k in ttff_dict.items():
- ttff_time.append(ttff_dict[i]['ttff_time'])
- ttff_pe.append(ttff_dict[i]['ttff_pe'])
- df['ttff_time'] = ttff_time
- df['ttff_pe'] = ttff_pe
- df.to_json(gps_log_path + '/gps_log.json', orient='table')
- 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)
- return ttff_data
-
- def verify_pe(self, mode):
- """
- Verify ttff Position Error with designate mode.
-
- Args:
- mode: A string for identify gnss test mode.
- """
-
- ffpe_type = namedtuple('Type', ['command', 'pecriteria'])
- ffpe_types = {
- 'cs': ffpe_type('Cold Start', self.cs_ttff_pecriteria),
- 'ws': ffpe_type('Warm Start', self.ws_ttff_pecriteria),
- 'hs': ffpe_type('Hot Start', self.hs_ttff_pecriteria)
- }
-
- if mode not in self.test_types:
- raise signals.TestError('Unrecognized mode %s' % mode)
- test_type = self.test_types.get(mode)
-
- ttff_data = self.get_and_verify_ttff(mode)
- result = gutils.check_ttff_pe(
- self.dut,
- ttff_data,
- ttff_mode=test_type.command,
- pecriteria=test_type.pecriteria
- )
- if not result:
- raise signals.TestFailure('%s TTFF fails to reach '
- 'designated criteria'
- % test_type.command)
- return ttff_data
-
- def clear_gps_log(self):
- """
- Delete the existing GPS GTW Log from DUT.
-
- """
- self.dut.adb.shell("rm -rf {}".format(DEVICE_GPSLOG_FOLDER))
+class LabTtffTest(lttb.LabTtffTestBase):
+ """ LAB Stand Alone TTFF Tests"""
def test_gnss_cold_ttff_ffpe(self):
-
- self.start_and_set_spectracom_power()
- if self.diag_option is "QCOM":
- diaglog.start_diagmdlog_background(self.dut, maskfile=self.maskfile)
- else:
- #start_tbdlog() yet to add for Broadcom
- pass
- self.verify_pe('cs')
- diaglog.stop_background_diagmdlog(self.dut, self.qxdm_log_path, keep_logs=False)
+ """
+ Cold start TTFF and FFPE Testing
+ """
+ mode = 'cs'
+ self.gnss_ttff_ffpe(mode)
def test_gnss_warm_ttff_ffpe(self):
-
- self.start_and_set_spectracom_power()
- if self.diag_option is "QCOM":
- diaglog.start_diagmdlog_background(self.dut, maskfile=self.maskfile)
- else:
- #start_tbdlog() yet to add for Broadcom
- pass
- self.verify_pe('ws')
- diaglog.stop_background_diagmdlog(self.dut, self.qxdm_log_path, keep_logs=False)
+ """
+ Warm start TTFF and FFPE Testing
+ """
+ mode = 'ws'
+ self.gnss_ttff_ffpe(mode)
def test_gnss_hot_ttff_ffpe(self):
-
- self.start_and_set_spectracom_power()
- if self.diag_option is "QCOM":
- diaglog.start_diagmdlog_background(self.dut, maskfile=self.maskfile)
- else:
- #start_tbdlog() yet to add for Broadcom
- pass
- self.verify_pe('hs')
- diaglog.stop_background_diagmdlog(self.dut, self.qxdm_log_path, keep_logs=False)
-
+ """
+ Hot start TTFF and FFPE Testing
+ """
+ mode = 'hs'
+ self.gnss_ttff_ffpe(mode)
diff --git a/acts_tests/tests/google/gnss/LocationPlatinumTest.py b/acts_tests/tests/google/gnss/LocationPlatinumTest.py
index ec80d87..6f4c253 100644
--- a/acts_tests/tests/google/gnss/LocationPlatinumTest.py
+++ b/acts_tests/tests/google/gnss/LocationPlatinumTest.py
@@ -22,14 +22,9 @@
from acts.base_test import BaseTestClass
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.tel_logging_utils import start_qxdm_logger
-from acts_contrib.test_utils.tel.tel_logging_utils import stop_qxdm_logger
-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
BACKGROUND_LOCATION_PERMISSION = 'android.permission.ACCESS_BACKGROUND_LOCATION'
-APP_CLEAN_UP_TIME = 60
+APP_CLEAN_UP_TIME = 10
class LocationPlatinumTest(BaseTestClass):
"""Location Platinum Tests"""
@@ -49,9 +44,7 @@
# Hot Start Criteria, a int to define the criteria.
'hs_criteria',
# NetworkLocationProvide Criteria, a int to define the criteria.
- 'nlp_criteria',
- # A list to identify QXDM log path.
- 'qdsp6m_path'
+ 'nlp_criteria'
]
self.unpack_userparams(req_param_names=req_params)
@@ -62,31 +55,19 @@
'ws': test_type('Warm Start', self.ws_criteria),
'hs': test_type('Hot Start', self.hs_criteria)
}
- gutils._init_device(self.ad)
- self.begin_time = utils.get_current_epoch_time()
- gutils.clear_logd_gnss_qxdm_log(self.ad)
- start_qxdm_logger(self.ad, self.begin_time)
- start_adb_tcpdump(self.ad)
+ self._init(self.ad)
+
+ def _init(self, ad):
+ gutils.enable_gnss_verbose_logging(ad)
+ if gutils.check_chipset_vendor_by_qualcomm(ad):
+ gutils.disable_xtra_throttle(ad)
def setup_test(self):
"""Prepare device with mobile data, wifi and gps ready for test """
- if int(self.ad.adb.shell('settings get secure location_mode')) != 3:
- self.ad.adb.shell('settings put secure location_mode 3')
+ 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)
- if int(self.ad.adb.shell('settings get global mobile_data')) != 1:
- gutils.set_mobile_data(self.ad, True)
- gutils.grant_location_permission(self.ad, True)
- self.ad.adb.shell('pm grant com.android.gpstool %s' %
- BACKGROUND_LOCATION_PERMISSION)
-
- def teardown_class(self):
- stop_qxdm_logger(self.ad)
- gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path)
- stop_adb_tcpdump(self.ad)
- get_tcpdump_log(self.ad, 'location_platinum', self.begin_time)
- self.ad.take_bug_report('location_platinum', self.begin_time)
def get_and_verify_ttff(self, mode):
"""Retrieve ttff with designate mode.
@@ -116,28 +97,28 @@
'%s TTFF fails to reach designated criteria' % test_type.command)
# Test cases
- def test_gnss_cold_ttff(self):
+ def test_gnss_cs_ttff(self):
"""
1. Send intent to GPSTool for cold start test.
2. Retrieve ttff and validate with target criteria.
"""
self.get_and_verify_ttff('cs')
- def test_gnss_warm_ttff(self):
+ def test_gnss_ws_ttff(self):
"""
1. Send intent to GPSTool for warm start test.
2. Retrieve ttff and validate with target criteria.
"""
self.get_and_verify_ttff('ws')
- def test_gnss_hot_ttff(self):
+ def test_gnss_hs_ttff(self):
"""
1. Send intent to GPSTool for hot start test.
2. Retrieve ttff and validate with target criteria.
"""
self.get_and_verify_ttff('hs')
- def test_nlp_available_by_wifi(self):
+ def test_nlp_by_wifi(self):
"""
1. Disable mobile data.
2. Send intent to GPSTool for NLP.
@@ -149,7 +130,7 @@
self.ad, 1, 'wifi', self.nlp_criteria),
'Fail to get NLP from wifi')
- def test_nlp_available_by_cell(self):
+ def test_nlp_by_cell(self):
"""
1. Disable wifi.
2. Send intent to GPSTool for NLP.
@@ -161,7 +142,7 @@
self.ad, 1, 'cell', self.nlp_criteria),
'Fail to get NLP from cell')
- def test_toggle_location_setting_off_on_report_location(self):
+ def test_toggle_location_setting_off_on(self):
"""
1. Toggle location setting off on.
2. Open Google Map and ask for location.
@@ -174,7 +155,7 @@
gutils.check_location_api(self.ad, retries=1),
'DUT failed to receive location fix')
- def test_toggle_location_setting_off_not_report_location(self):
+ def test_location_setting_off(self):
"""
1. Toggle location setting off.
2. Open Google Map and ask for location.
@@ -199,7 +180,7 @@
gutils.check_location_api(self.ad, retries=1),
'DUT fail to receive location fix')
- def test_toggle_location_permission_off(self):
+ def test_location_permission_off(self):
"""
1. Toggle Google Map location permission off.
2. Open Google Map and ask for location.
diff --git a/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py b/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
index 2d0bc9d..419c418 100644
--- a/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBTa2dpTest.py
@@ -19,9 +19,17 @@
import acts_contrib.test_utils.power.PowerBTBaseTest as PBtBT
from acts import asserts
from acts_contrib.test_utils.bt import BtEnum
+from acts.libs.proc import job
+DEFAULT_ADB_TIMEOUT = 60
EXTRA_PLAY_TIME = 10
-
+GET_PROPERTY_HARDWARE_PLATFORM = 'getprop ro.boot.hardware.platform'
+PL_MAP = {
+ '10': 'EPA_BF',
+ '9': 'EPA_DIV',
+ '8': 'IPA_BF',
+ '7': 'IPA_DIV',
+}
class PowerBTa2dpTest(PBtBT.PowerBTBaseTest):
def __init__(self, configs):
@@ -45,10 +53,32 @@
def test_case_fn():
self.measure_a2dp_power(codec_config, tpl)
- test_case_name = ('test_BTa2dp_{}_codec_at_PL{}'.format(
- codec_config['codec_type'], tpl))
+ power_level = 'PL{}'.format(tpl)
+
+ # If the device is P21 and later, generate tests with different name.
+ platform = self._get_hardware_platform_at_init_stage()
+ self.log.info('Hardware Platform is: {}'.format(platform))
+ if platform.startswith('gs'):
+ power_level = PL_MAP[str(tpl)]
+ self.log.info('The device is P21 or later, use name {}'.format(
+ power_level))
+
+ test_case_name = ('test_BTa2dp_{}_codec_at_{}'.format(
+ codec_config['codec_type'], power_level))
setattr(self, test_case_name, test_case_fn)
+ def _get_hardware_platform_at_init_stage(self):
+
+ # At __init__ stage the android devices are not registered. Thus, run
+ # adb command with device sn directly.
+ sn = self.controller_configs['AndroidDevice'][0]
+ cmd = 'adb -s {} shell {}'.format(sn, GET_PROPERTY_HARDWARE_PLATFORM)
+ result = job.run(cmd, ignore_status=True, timeout=DEFAULT_ADB_TIMEOUT)
+ ret, out, err = result.exit_status, result.stdout, result.stderr
+ self.log.info('get platform ret: {}, out: {}, err: {}'.format(
+ ret, out, err))
+ return out
+
def measure_a2dp_power(self, codec_config, tpl):
current_codec = self.dut.droid.bluetoothA2dpGetCurrentCodecConfig()
diff --git a/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py b/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
index 13b3f39..c0bac23 100644
--- a/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
+++ b/acts_tests/tests/google/power/bt/PowerBTcalibrationTest.py
@@ -21,6 +21,7 @@
import acts_contrib.test_utils.power.PowerBTBaseTest as PBtBT
EXTRA_PLAY_TIME = 30
+GET_PROPERTY_HARDWARE_PLATFORM = 'getprop ro.boot.hardware.platform'
class PowerBTcalibrationTest(PBtBT.PowerBTBaseTest):
@@ -50,20 +51,23 @@
self.media.play()
time.sleep(EXTRA_PLAY_TIME)
- # Loop through attenuation in 1 dB step until reaching at PL10
+ # Loop through attenuation in 1 dB step
self.log.info('Starting Calibration Process')
- pl10_count = 0
for i in range(int(self.attenuator.get_max_atten())):
-
- self.attenuator.set_atten(i)
- bt_metrics_dict = btutils.get_bt_metric(self.dut)
- pwl = bt_metrics_dict['pwlv'][self.dut.serial]
- self.log.info('Reach PW {} at attenuation {} dB'.format(pwl, i))
- self.cal_matrix.append([i, pwl])
- if pwl == 10:
- pl10_count += 1
- if pl10_count > 5:
- break
+ try:
+ self.attenuator.set_atten(i)
+ bt_metrics_dict = btutils.get_bt_metric(self.dut)
+ pwl = bt_metrics_dict['pwlv'][self.dut.serial]
+ rssi = bt_metrics_dict['rssi'][self.dut.serial]
+ bftx = bt_metrics_dict['bftx'][self.dut.serial]
+ self.log.info(
+ 'Reach PW {}, RSSI {}, BFTX {} at attenuation {} dB'.format(
+ pwl, rssi, bftx, i))
+ except Exception as e:
+ self.log.warning('Get Exception {} at attenuation {} dB'.format(
+ str(e), i))
+ continue
+ self.cal_matrix.append([i, pwl, rssi, bftx])
# Write cal results to csv
with open(self.log_file, 'w', newline='') as f:
diff --git a/acts_tests/tests/google/power/wifi/PowerWiFidtimTest.py b/acts_tests/tests/google/power/wifi/PowerWiFidtimTest.py
index 2d6eec1..bb68233 100644
--- a/acts_tests/tests/google/power/wifi/PowerWiFidtimTest.py
+++ b/acts_tests/tests/google/power/wifi/PowerWiFidtimTest.py
@@ -18,6 +18,7 @@
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_power_test_utils as wputils
+from acts.controllers.adb_lib.error import AdbCommandError
class PowerWiFidtimTest(PWBT.PowerWiFiBaseTest):
@@ -33,17 +34,34 @@
attrs = ['screen_status', 'wifi_band', 'dtim']
indices = [2, 4, 6]
self.decode_test_configs(attrs, indices)
- # Initialize the dut to rock-bottom state
- rebooted = wputils.change_dtim(
- self.dut,
- gEnableModulatedDTIM=int(self.test_configs.dtim),
- gMaxLIModulatedDTIM=dtim_max)
- if rebooted:
- self.dut_rockbottom()
- self.dut.log.info('DTIM value of the phone is now {}'.format(
- self.test_configs.dtim))
- self.setup_ap_connection(
- self.main_network[self.test_configs.wifi_band])
+
+ # Starts from P21 device, the dtim setting method is changed to use adb.
+ # If no file match '/vendor/firmware/wlan/*/*.ini', use adb to change
+ # the dtim.
+ change_dtim_with_adb = False
+ try:
+ self.dut.adb.shell('ls /vendor/firmware/wlan/*/*.ini')
+ except AdbCommandError as e:
+ change_dtim_with_adb = True
+
+ if not change_dtim_with_adb:
+ # Initialize the dut to rock-bottom state
+ rebooted = wputils.change_dtim(
+ self.dut,
+ gEnableModulatedDTIM=int(self.test_configs.dtim),
+ gMaxLIModulatedDTIM=dtim_max)
+ if rebooted:
+ self.dut_rockbottom()
+ self.dut.log.info('DTIM value of the phone is now {}'.format(
+ self.test_configs.dtim))
+ self.setup_ap_connection(self.main_network[self.test_configs.wifi_band])
+
+ if change_dtim_with_adb:
+ self.dut.log.info('No ini file for dtim, change dtim with adb')
+ wputils.change_dtim_adb(
+ self.dut,
+ gEnableModulatedDTIM=int(self.test_configs.dtim))
+
if self.test_configs.screen_status == 'OFF':
self.dut.droid.goToSleepNow()
self.dut.log.info('Screen is OFF')
@@ -56,7 +74,10 @@
self.dtim_test_func()
@test_tracker_info(uuid='384d3b0f-4335-4b00-8363-308ec27a150c')
- def test_screen_ON_band_2g_dtim_1(self):
+ def test_screen_OFF_band_2g_dtim_8(self):
+ self.dtim_test_func()
+
+ def test_screen_OFF_band_2g_dtim_9(self):
self.dtim_test_func()
@test_tracker_info(uuid='017f57c3-e133-461d-80be-d025d1491d8a')
@@ -64,5 +85,8 @@
self.dtim_test_func()
@test_tracker_info(uuid='327af44d-d9e7-49e0-9bda-accad6241dc7')
- def test_screen_ON_band_5g_dtim_1(self):
+ def test_screen_OFF_band_5g_dtim_8(self):
+ self.dtim_test_func()
+
+ def test_screen_OFF_band_5g_dtim_9(self):
self.dtim_test_func()
diff --git a/acts_tests/tests/google/power/wifi/PowerWiFimulticastTest.py b/acts_tests/tests/google/power/wifi/PowerWiFimulticastTest.py
index 8b7e063..f0559e4 100644
--- a/acts_tests/tests/google/power/wifi/PowerWiFimulticastTest.py
+++ b/acts_tests/tests/google/power/wifi/PowerWiFimulticastTest.py
@@ -19,6 +19,7 @@
from acts_contrib.test_utils.power import PowerWiFiBaseTest as PWBT
from acts_contrib.test_utils.wifi import wifi_power_test_utils as wputils
from acts.controllers import packet_sender as pkt_utils
+from acts.controllers.adb_lib.error import AdbCommandError
RA_SHORT_LIFETIME = 3
RA_LONG_LIFETIME = 1000
@@ -54,18 +55,35 @@
indices = [2, 4]
self.decode_test_configs(attrs, indices)
# Change DTIMx1 on the phone to receive all Multicast packets
- rebooted = wputils.change_dtim(self.dut,
- gEnableModulatedDTIM=1,
- gMaxLIModulatedDTIM=10)
- self.dut.log.info('DTIM value of the phone is now DTIMx1')
- if rebooted:
- self.dut_rockbottom()
+
+ # Starts from P21 device, the dtim setting method is changed to use adb.
+ # If no file match '/vendor/firmware/wlan/*/*.ini', use adb to change
+ # the dtim.
+ change_dtim_with_adb = False
+ try:
+ self.dut.adb.shell('ls /vendor/firmware/wlan/*/*.ini')
+ except AdbCommandError as e:
+ change_dtim_with_adb = True
+
+ if not change_dtim_with_adb:
+ # Initialize the dut to rock-bottom state
+ rebooted = wputils.change_dtim(
+ self.dut,
+ gEnableModulatedDTIM=1,
+ gMaxLIModulatedDTIM=10)
+ if rebooted:
+ self.dut_rockbottom()
+ self.dut.log.info('DTIM value of the phone is now DTIMx1')
self.setup_ap_connection(
self.main_network[self.test_configs.wifi_band])
# Wait for DHCP with timeout of 60 seconds
wputils.wait_for_dhcp(self.pkt_sender.interface)
+ if change_dtim_with_adb:
+ self.dut.log.info('No ini file for dtim, change dtim with adb')
+ wputils.change_dtim_adb(self.dut, gEnableModulatedDTIM=1)
+
# Set the desired screen status
if self.test_configs.screen_status == 'OFF':
self.dut.droid.goToSleepNow()
diff --git a/acts_tests/tests/google/wifi/WifiManagerTest.py b/acts_tests/tests/google/wifi/WifiManagerTest.py
index 902272c..d2a07dc 100644
--- a/acts_tests/tests/google/wifi/WifiManagerTest.py
+++ b/acts_tests/tests/google/wifi/WifiManagerTest.py
@@ -205,8 +205,8 @@
" match. \nBefore reboot = %s \n After reboot = %s" %
(networks, network_info))
raise signals.TestFailure(msg)
- current_count = 0
# For each network, check if it exists in configured list after reboot
+ current_ssids = set()
for network in networks:
exists = wutils.match_networks({
WifiEnums.SSID_KEY: network[WifiEnums.SSID_KEY]
@@ -218,10 +218,10 @@
# Get the new network id for each network after reboot.
network[WifiEnums.NETID_KEY] = exists[0]['networkId']
if exists[0]['status'] == 'CURRENT':
- current_count += 1
+ current_ssids.add(network[WifiEnums.SSID_KEY])
# At any given point, there can only be one currently active
# network, defined with 'status':'CURRENT'
- if current_count > 1:
+ if len(current_ssids) > 1:
raise signals.TestFailure("More than one network showing"
"as 'CURRENT' after reboot")
diff --git a/acts_tests/tests/google/wifi/WifiPingTest.py b/acts_tests/tests/google/wifi/WifiPingTest.py
index ea45381..096a935 100644
--- a/acts_tests/tests/google/wifi/WifiPingTest.py
+++ b/acts_tests/tests/google/wifi/WifiPingTest.py
@@ -29,6 +29,7 @@
from acts_contrib.test_utils.wifi import ota_chamber
from acts_contrib.test_utils.wifi import ota_sniffer
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 acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from functools import partial
@@ -79,7 +80,11 @@
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
if hasattr(self,
'OTASniffer') and self.testbed_params['sniffer_enable']:
- self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
self.log_path = os.path.join(logging.log_path, 'results')
@@ -98,9 +103,13 @@
self.user_params['retry_tests'] = [self.__class__.__name__]
def teardown_class(self):
+ for attenuator in self.attenuators:
+ attenuator.set_atten(0, strict=False, retry=True)
# Turn WiFi OFF and reset AP
+ self.access_point.teardown()
for dev in self.android_devices:
wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
self.process_testclass_results()
def setup_test(self):
@@ -132,7 +141,9 @@
results_file_path = os.path.join(self.log_path,
'testclass_summary.json')
with open(results_file_path, 'w') as results_file:
- json.dump(testclass_summary, results_file, indent=4)
+ json.dump(wputils.serialize_dict(testclass_summary),
+ results_file,
+ indent=4)
def pass_fail_check_ping_rtt(self, result):
"""Check the test result and decide if it passed or failed.
@@ -232,6 +243,10 @@
range_index]
ping_range_result['peak_throughput_pct'] = 100 - min(
ping_loss_over_att)
+ ping_range_result['total_attenuation'] = [
+ ping_range_result['fixed_attenuation'] + att
+ for att in testcase_params['atten_range']
+ ]
ping_range_result['range'] = (ping_range_result['atten_at_range'] +
ping_range_result['fixed_attenuation'])
ping_range_result['llstats_at_range'] = (
@@ -248,14 +263,15 @@
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(ping_range_result, results_file, indent=4)
+ json.dump(wputils.serialize_dict(ping_range_result),
+ results_file,
+ indent=4)
# Plot results
- if 'range' not in self.current_test_name:
- figure = wputils.BokehFigure(
- self.current_test_name,
- x_label='Timestamp (s)',
- primary_y_label='Round Trip Time (ms)')
+ if 'rtt' in self.current_test_name:
+ figure = BokehFigure(self.current_test_name,
+ x_label='Timestamp (s)',
+ primary_y_label='Round Trip Time (ms)')
for idx, result in enumerate(ping_range_result['ping_results']):
if len(result['rtt']) > 1:
x_data = [
@@ -298,50 +314,86 @@
if self.testbed_params['sniffer_enable']:
self.sniffer.start_capture(
testcase_params['test_network'],
- chan=int(testcase_params['channel']),
+ chan=testcase_params['channel'],
bw=testcase_params['bandwidth'],
duration=testcase_params['ping_duration'] *
len(testcase_params['atten_range']) + self.TEST_TIMEOUT)
# Run ping and sweep attenuation as needed
zero_counter = 0
+ pending_first_ping = 1
for atten in testcase_params['atten_range']:
for attenuator in self.attenuators:
attenuator.set_atten(atten, strict=False, retry=True)
- rssi_future = wputils.get_connected_rssi_nb(
- self.dut,
- int(testcase_params['ping_duration'] / 2 /
- self.RSSI_POLL_INTERVAL), self.RSSI_POLL_INTERVAL,
- testcase_params['ping_duration'] / 2)
+ if self.testclass_params.get('monitor_rssi', 1):
+ rssi_future = wputils.get_connected_rssi_nb(
+ self.dut,
+ int(testcase_params['ping_duration'] / 2 /
+ self.RSSI_POLL_INTERVAL), self.RSSI_POLL_INTERVAL,
+ testcase_params['ping_duration'] / 2)
# Refresh link layer stats
llstats_obj.update_stats()
- current_ping_stats = wputils.get_ping_stats(
- self.ping_server, self.dut_ip,
- testcase_params['ping_duration'],
- testcase_params['ping_interval'], testcase_params['ping_size'])
- current_rssi = rssi_future.result()
+ if testcase_params.get('ping_from_dut', False):
+ current_ping_stats = wputils.get_ping_stats(
+ self.dut,
+ wputils.get_server_address(self.ping_server, self.dut_ip,
+ '255.255.255.0'),
+ testcase_params['ping_duration'],
+ testcase_params['ping_interval'],
+ testcase_params['ping_size'])
+ else:
+ current_ping_stats = wputils.get_ping_stats(
+ self.ping_server, self.dut_ip,
+ testcase_params['ping_duration'],
+ testcase_params['ping_interval'],
+ testcase_params['ping_size'])
+ if self.testclass_params.get('monitor_rssi', 1):
+ current_rssi = rssi_future.result()
+ else:
+ current_rssi = collections.OrderedDict([
+ ('time_stamp', []), ('bssid', []), ('ssid', []),
+ ('frequency', []),
+ ('signal_poll_rssi', wputils.empty_rssi_result()),
+ ('signal_poll_avg_rssi', wputils.empty_rssi_result()),
+ ('chain_0_rssi', wputils.empty_rssi_result()),
+ ('chain_1_rssi', wputils.empty_rssi_result())
+ ])
test_result['rssi_results'].append(current_rssi)
llstats_obj.update_stats()
curr_llstats = llstats_obj.llstats_incremental.copy()
test_result['llstats'].append(curr_llstats)
if current_ping_stats['connected']:
+ llstats_str = 'TX MCS = {0} ({1:.1f}%). RX MCS = {2} ({3:.1f}%)'.format(
+ curr_llstats['summary']['common_tx_mcs'],
+ curr_llstats['summary']['common_tx_mcs_freq'] * 100,
+ curr_llstats['summary']['common_rx_mcs'],
+ curr_llstats['summary']['common_rx_mcs_freq'] * 100)
self.log.info(
'Attenuation = {0}dB\tPacket Loss = {1:.1f}%\t'
- 'Avg RTT = {2:.2f}ms\tRSSI = {3:.2f} [{4},{5}]\t'.format(
- atten, current_ping_stats['packet_loss_percentage'],
- statistics.mean(current_ping_stats['rtt']),
- current_rssi['signal_poll_rssi']['mean'],
- current_rssi['chain_0_rssi']['mean'],
- current_rssi['chain_1_rssi']['mean']))
+ 'Avg RTT = {2:.2f}ms\tRSSI = {3:.1f} [{4:.1f},{5:.1f}]\t{6}\t'
+ .format(atten,
+ current_ping_stats['packet_loss_percentage'],
+ statistics.mean(current_ping_stats['rtt']),
+ current_rssi['signal_poll_rssi']['mean'],
+ current_rssi['chain_0_rssi']['mean'],
+ current_rssi['chain_1_rssi']['mean'], llstats_str))
if current_ping_stats['packet_loss_percentage'] == 100:
zero_counter = zero_counter + 1
else:
zero_counter = 0
+ pending_first_ping = 0
else:
self.log.info(
'Attenuation = {}dB. Disconnected.'.format(atten))
zero_counter = zero_counter + 1
test_result['ping_results'].append(current_ping_stats.as_dict())
- if zero_counter == self.MAX_CONSECUTIVE_ZEROS:
+ # Test ends when ping loss stable at 0. If test has successfully
+ # started, test ends on MAX_CONSECUTIVE_ZEROS. In case of a restry
+ # extra zeros are allowed to ensure a test properly starts.
+ if self.retry_flag and pending_first_ping:
+ allowable_zeros = self.MAX_CONSECUTIVE_ZEROS**2
+ else:
+ allowable_zeros = self.MAX_CONSECUTIVE_ZEROS
+ if zero_counter == allowable_zeros:
self.log.info('Ping loss stable at 100%. Stopping test now.')
for idx in range(
len(testcase_params['atten_range']) -
@@ -349,6 +401,11 @@
test_result['ping_results'].append(
self.DISCONNECTED_PING_RESULT)
break
+ # Set attenuator to initial setting
+ for attenuator in self.attenuators:
+ attenuator.set_atten(testcase_params['atten_range'][0],
+ strict=False,
+ retry=True)
if self.testbed_params['sniffer_enable']:
self.sniffer.stop_capture()
return test_result
@@ -361,12 +418,16 @@
"""
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
- if '2G' in band:
- frequency = wutils.WifiEnums.channel_2G_to_freq[
- testcase_params['channel']]
+ if '6G' in band:
+ frequency = wutils.WifiEnums.channel_6G_to_freq[int(
+ testcase_params['channel'].strip('6g'))]
else:
- frequency = wutils.WifiEnums.channel_5G_to_freq[
- testcase_params['channel']]
+ if testcase_params['channel'] < 13:
+ frequency = wutils.WifiEnums.channel_2G_to_freq[
+ testcase_params['channel']]
+ else:
+ frequency = wutils.WifiEnums.channel_5G_to_freq[
+ testcase_params['channel']]
if frequency in wutils.WifiEnums.DFS_5G_FREQUENCIES:
self.access_point.set_region(self.testbed_params['DFS_region'])
else:
@@ -380,34 +441,47 @@
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
- def setup_dut(self, testcase_params):
- """Sets up the DUT in the configuration required by the test.
-
- Args:
- testcase_params: dict containing AP and other test params
- """
- # Check battery level before test
- if not wputils.health_check(self.dut, 10):
- asserts.skip('Battery level too low. Skipping test.')
- # Turn screen off to preserve battery
- self.dut.go_to_sleep()
+ def validate_and_connect(self, testcase_params):
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
else:
- wutils.wifi_toggle_state(self.dut, False)
- wutils.set_wifi_country_code(self.dut,
- self.testclass_params['country_code'])
- wutils.wifi_toggle_state(self.dut, True)
- wutils.reset_wifi(self.dut)
- wutils.set_wifi_country_code(self.dut,
- self.testclass_params['country_code'])
+ current_country = wputils.get_country_code(self.dut)
+ if current_country != self.testclass_params['country_code']:
+ self.log.warning(
+ 'Requested CC: {}, Current CC: {}. Resetting WiFi'.format(
+ self.testclass_params['country_code'],
+ current_country))
+ wutils.wifi_toggle_state(self.dut, False)
+ wutils.set_wifi_country_code(
+ self.dut, self.testclass_params['country_code'])
+ wutils.wifi_toggle_state(self.dut, True)
+ wutils.reset_wifi(self.dut)
+ wutils.set_wifi_country_code(
+ self.dut, self.testclass_params['country_code'])
+ if self.testbed_params.get('txbf_off', False):
+ wputils.disable_beamforming(self.dut)
testcase_params['test_network']['channel'] = testcase_params[
'channel']
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
num_of_tries=5,
check_connectivity=True)
+
+ def setup_dut(self, testcase_params):
+ """Sets up the DUT in the configuration required by the test.
+
+ Args:
+ testcase_params: dict containing AP and other test params
+ """
+ # Turn screen off to preserve battery
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
+ self.validate_and_connect(testcase_params)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
if testcase_params['channel'] not in self.atten_dut_chain_map.keys():
self.atten_dut_chain_map[testcase_params[
@@ -432,7 +506,9 @@
self.setup_ap(testcase_params)
# Set attenuator to 0 dB
for attenuator in self.attenuators:
- attenuator.set_atten(0, strict=False, retry=True)
+ attenuator.set_atten(testcase_params['atten_range'][0],
+ strict=False,
+ retry=True)
# Reset, configure, and connect DUT
self.setup_dut(testcase_params)
@@ -450,6 +526,11 @@
return self.testclass_params['range_atten_start']
def compile_test_params(self, testcase_params):
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
testcase_params['test_network'] = self.main_network[band]
@@ -520,11 +601,11 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
for channel, mode, chain, test_type in itertools.product(
@@ -549,25 +630,33 @@
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],
- 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', 'bw40', 'bw80'],
+ test_types=[
+ 'test_ping_range',
+ 'test_fast_ping_rtt',
+ 'test_slow_ping_rtt'
+ ],
+ chain_mask=['2x2'])
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],
- 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', 'bw40', 'bw80'],
+ test_types=['test_ping_range'])
class WifiPing_LowPowerAP_Test(WifiPingTest):
@@ -614,21 +703,24 @@
range_vs_angle = collections.OrderedDict()
for test in self.testclass_results:
curr_params = test['testcase_params']
- curr_config = curr_params['channel']
- if curr_config in range_vs_angle:
- if curr_params['position'] not in range_vs_angle[curr_config][
- 'position']:
- range_vs_angle[curr_config]['position'].append(
+ curr_config = wputils.extract_sub_dict(
+ curr_params, ['channel', 'mode', 'chain_mask'])
+ curr_config_id = tuple(curr_config.items())
+ if curr_config_id in range_vs_angle:
+ if curr_params['position'] not in range_vs_angle[
+ curr_config_id]['position']:
+ range_vs_angle[curr_config_id]['position'].append(
curr_params['position'])
- range_vs_angle[curr_config]['range'].append(test['range'])
- range_vs_angle[curr_config]['llstats_at_range'].append(
+ range_vs_angle[curr_config_id]['range'].append(
+ test['range'])
+ range_vs_angle[curr_config_id]['llstats_at_range'].append(
test['llstats_at_range'])
else:
- range_vs_angle[curr_config]['range'][-1] = test['range']
- range_vs_angle[curr_config]['llstats_at_range'][-1] = test[
- 'llstats_at_range']
+ range_vs_angle[curr_config_id]['range'][-1] = test['range']
+ range_vs_angle[curr_config_id]['llstats_at_range'][
+ -1] = test['llstats_at_range']
else:
- range_vs_angle[curr_config] = {
+ range_vs_angle[curr_config_id] = {
'position': [curr_params['position']],
'range': [test['range']],
'llstats_at_range': [test['llstats_at_range']]
@@ -639,21 +731,24 @@
x_label = 'Angle (deg)'
elif chamber_mode == 'stepped stirrers':
x_label = 'Position Index'
- figure = wputils.BokehFigure(
+ figure = BokehFigure(
title='Range vs. Position',
x_label=x_label,
primary_y_label='Range (dB)',
)
- for channel, channel_data in range_vs_angle.items():
- figure.add_line(x_data=channel_data['position'],
- y_data=channel_data['range'],
- hover_text=channel_data['llstats_at_range'],
- legend='Channel {}'.format(channel))
- average_range = sum(channel_data['range']) / len(
- channel_data['range'])
- self.log.info('Average range for Channel {} is: {}dB'.format(
- channel, average_range))
- metric_name = 'ota_summary_ch{}.avg_range'.format(channel)
+ for curr_config_id, curr_config_data in range_vs_angle.items():
+ curr_config = collections.OrderedDict(curr_config_id)
+ figure.add_line(x_data=curr_config_data['position'],
+ y_data=curr_config_data['range'],
+ hover_text=curr_config_data['llstats_at_range'],
+ legend='{}'.format(curr_config_id))
+ average_range = sum(curr_config_data['range']) / len(
+ curr_config_data['range'])
+ self.log.info('Average range for {} is: {}dB'.format(
+ curr_config_id, average_range))
+ metric_name = 'ota_summary_ch{}_{}_ch{}.avg_range'.format(
+ curr_config['channel'], curr_config['mode'],
+ curr_config['chain_mask'])
self.testclass_metric_logger.add_metric(metric_name, average_range)
current_context = context.get_current_context().get_full_output_path()
plot_file_path = os.path.join(current_context, 'results.html')
@@ -663,20 +758,35 @@
results_file_path = os.path.join(current_context,
'testclass_summary.json')
with open(results_file_path, 'w') as results_file:
- json.dump(range_vs_angle, results_file, indent=4)
+ json.dump(wputils.serialize_dict(range_vs_angle),
+ results_file,
+ indent=4)
+
+ def setup_dut(self, testcase_params):
+ """Sets up the DUT in the configuration required by the test.
+
+ Args:
+ testcase_params: dict containing AP and other test params
+ """
+ wputils.set_chain_mask(self.dut, testcase_params['chain_mask'])
+ # Turn screen off to preserve battery
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
+ self.validate_and_connect(testcase_params)
+ self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def setup_ping_test(self, testcase_params):
- WifiPingTest.setup_ping_test(self, testcase_params)
# Setup turntable
if testcase_params['chamber_mode'] == 'orientation':
self.ota_chamber.set_orientation(testcase_params['position'])
elif testcase_params['chamber_mode'] == 'stepped stirrers':
self.ota_chamber.step_stirrers(testcase_params['total_positions'])
-
- def extract_test_id(self, testcase_params, id_fields):
- test_id = collections.OrderedDict(
- (param, testcase_params[param]) for param in id_fields)
- return test_id
+ # 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.
@@ -694,12 +804,12 @@
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 = self.extract_test_id(testcase_params,
- ['channel', 'mode'])
+ 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 = [
- self.extract_test_id(result['testcase_params'],
- ['channel', 'mode'])
+ wputils.extract_sub_dict(result['testcase_params'],
+ ['channel', 'mode', 'chain_mask'])
for result in self.testclass_results
]
try:
@@ -715,32 +825,32 @@
start_atten = self.testclass_params['range_atten_start']
return start_atten
- def generate_test_cases(self, ap_power, channels, modes, chamber_mode,
- positions):
+ def generate_test_cases(self, ap_power, channels, modes, chain_masks,
+ chamber_mode, positions):
test_cases = []
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
- for channel, mode, position in itertools.product(
- channels, modes, positions):
+ for channel, mode, chain_mask, position in itertools.product(
+ channels, modes, chain_masks, positions):
bandwidth = int(''.join([x for x in mode if x.isdigit()]))
if channel not in allowed_configs[bandwidth]:
continue
- testcase_name = 'test_ping_range_ch{}_{}_pos{}'.format(
- channel, mode, position)
+ testcase_name = 'test_ping_range_ch{}_{}_ch{}_pos{}'.format(
+ channel, mode, chain_mask, position)
testcase_params = collections.OrderedDict(
test_type='test_ping_range',
ap_power=ap_power,
channel=channel,
mode=mode,
bandwidth=bandwidth,
- chain_mask='2x2',
+ chain_mask=chain_mask,
chamber_mode=chamber_mode,
total_positions=len(positions),
position=position)
@@ -753,23 +863,29 @@
class WifiOtaPing_TenDegree_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'],
- chamber_mode='orientation',
- positions=list(range(0, 360,
- 10)))
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[6, 36, 149, '6g37', '6g117', '6g213'],
+ modes=['bw20'],
+ chain_masks=['2x2'],
+ chamber_mode='orientation',
+ positions=list(range(0, 360, 10)))
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],
- modes=['bw20'],
- 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)))
class WifiOtaPing_SteppedStirrers_Test(WifiOtaPingTest):
@@ -778,6 +894,7 @@
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)))
@@ -788,6 +905,7 @@
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)))
@@ -800,6 +918,7 @@
ap_power='low_power',
channels=[1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
modes=['bw20'],
+ chain_masks=['2x2'],
chamber_mode='orientation',
positions=list(range(0, 360, 45)))
@@ -810,5 +929,30 @@
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)))
\ No newline at end of file
+ positions=list(range(100)))
+
+
+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)))
+
+
+class WifiOtaPing_PerChain_TenDegree_Test(WifiOtaPingTest):
+ def __init__(self, controllers):
+ WifiOtaPingTest.__init__(self, controllers)
+ self.tests = self.generate_test_cases(
+ ap_power='standard',
+ channels=[6, 36, 149, '6g37', '6g117', '6g213'],
+ modes=['bw20'],
+ chain_masks=[0, 1, '2x2'],
+ chamber_mode='orientation',
+ positions=list(range(0, 360, 10)))
diff --git a/acts_tests/tests/google/wifi/WifiPnoTest.py b/acts_tests/tests/google/wifi/WifiPnoTest.py
index d93fa45..5378b8f 100644
--- a/acts_tests/tests/google/wifi/WifiPnoTest.py
+++ b/acts_tests/tests/google/wifi/WifiPnoTest.py
@@ -62,6 +62,9 @@
self.dut.droid.goToSleepNow()
wutils.reset_wifi(self.dut)
self.dut.ed.clear_all_events()
+ # DUT to the saved networks so they won't be excluded from PNO scan.
+ wutils.connect_to_wifi_network(self.dut, self.pno_network_a)
+ wutils.connect_to_wifi_network(self.dut, self.pno_network_b)
def teardown_test(self):
super().teardown_test()
@@ -197,9 +200,6 @@
self.add_network_and_enable(self.pno_network_b)
# Force single scan so that both networks become preferred before PNO.
wutils.start_wifi_connection_scan_and_return_status(self.dut)
- self.dut.droid.goToSleepNow()
- wutils.wifi_toggle_state(self.dut, False)
- wutils.wifi_toggle_state(self.dut, True)
time.sleep(10)
self.trigger_pno_and_assert_connect("b_on_a_off", self.pno_network_b)
diff --git a/acts_tests/tests/google/wifi/WifiRoamingPerformanceTest.py b/acts_tests/tests/google/wifi/WifiRoamingPerformanceTest.py
index db42e2e..2c739c6 100644
--- a/acts_tests/tests/google/wifi/WifiRoamingPerformanceTest.py
+++ b/acts_tests/tests/google/wifi/WifiRoamingPerformanceTest.py
@@ -28,6 +28,7 @@
from acts.controllers.utils_lib import ssh
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 acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
@@ -221,7 +222,7 @@
roam_stats = collections.OrderedDict()
current_context = context.get_current_context().get_full_output_path()
for secondary_atten, results_list in results_dict.items():
- figure = wputils.BokehFigure(title=self.current_test_name,
+ figure = BokehFigure(title=self.current_test_name,
x_label='Time (ms)',
primary_y_label=primary_y_axis,
secondary_y_label='RSSI (dBm)')
@@ -383,7 +384,7 @@
output_file_path: optional path to output file
"""
if not figure:
- figure = wputils.BokehFigure(title=self.current_test_name,
+ figure = BokehFigure(title=self.current_test_name,
x_label='Time (ms)',
primary_y_label='RTT (ms)',
secondary_y_label='RSSI (dBm)')
@@ -418,7 +419,7 @@
output_file_path: optional path to output file
"""
if not figure:
- figure = wputils.BokehFigure(title=self.current_test_name,
+ figure = BokehFigure(title=self.current_test_name,
x_label='Time (s)',
primary_y_label='Throughput (Mbps)',
secondary_y_label='RSSI (dBm)')
diff --git a/acts_tests/tests/google/wifi/WifiRssiTest.py b/acts_tests/tests/google/wifi/WifiRssiTest.py
index 1c0c6df..06eed43 100644
--- a/acts_tests/tests/google/wifi/WifiRssiTest.py
+++ b/acts_tests/tests/google/wifi/WifiRssiTest.py
@@ -31,6 +31,7 @@
from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
from acts_contrib.test_utils.wifi import ota_chamber
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 acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from concurrent.futures import ThreadPoolExecutor
@@ -90,6 +91,13 @@
def teardown_test(self):
self.iperf_server.stop()
+ def teardown_class(self):
+ # Turn WiFi OFF and reset AP
+ self.access_point.teardown()
+ for dev in self.android_devices:
+ wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
+
def pass_fail_check_rssi_stability(self, testcase_params,
postprocessed_results):
"""Check the test result and decide if it passed or failed.
@@ -220,7 +228,9 @@
# Save output as text file
results_file_path = os.path.join(self.log_path, self.current_test_name)
with open(results_file_path, 'w') as results_file:
- json.dump(rssi_result, results_file, indent=4)
+ json.dump(wputils.serialize_dict(rssi_result),
+ results_file,
+ indent=4)
# Compile results into arrays of RSSIs suitable for plotting
# yapf: disable
postprocessed_results = collections.OrderedDict(
@@ -291,9 +301,9 @@
Args:
postprocessed_results: compiled arrays of RSSI data.
"""
- figure = wputils.BokehFigure(self.current_test_name,
- x_label='Attenuation (dB)',
- primary_y_label='RSSI (dBm)')
+ figure = BokehFigure(self.current_test_name,
+ x_label='Attenuation (dB)',
+ primary_y_label='RSSI (dBm)')
figure.add_line(postprocessed_results['total_attenuation'],
postprocessed_results['signal_poll_rssi']['mean'],
'Signal Poll RSSI',
@@ -329,7 +339,7 @@
center_curvers: boolean indicating whether to shift curves to align
them with predicted RSSIs
"""
- figure = wputils.BokehFigure(
+ figure = BokehFigure(
self.current_test_name,
x_label='Time (s)',
primary_y_label=center_curves * 'Centered' + 'RSSI (dBm)',
@@ -405,10 +415,10 @@
cum_prob += prob
rssi_dist[rssi_key]['rssi_cdf'].append(cum_prob)
- figure = wputils.BokehFigure(self.current_test_name,
- x_label='RSSI (dBm)',
- primary_y_label='p(RSSI = x)',
- secondary_y_label='p(RSSI <= x)')
+ figure = BokehFigure(self.current_test_name,
+ x_label='RSSI (dBm)',
+ primary_y_label='p(RSSI = x)',
+ secondary_y_label='p(RSSI <= x)')
for rssi_key, rssi_data in rssi_dist.items():
figure.add_line(x_data=rssi_data['rssi_values'],
y_data=rssi_data['rssi_pdf'],
@@ -522,12 +532,18 @@
Args:
testcase_params: dict containing test-specific parameters
"""
- if '2G' in testcase_params['band']:
- frequency = wutils.WifiEnums.channel_2G_to_freq[
- testcase_params['channel']]
+ band = self.access_point.band_lookup_by_channel(
+ testcase_params['channel'])
+ if '6G' in band:
+ frequency = wutils.WifiEnums.channel_6G_to_freq[int(
+ testcase_params['channel'].strip('6g'))]
else:
- frequency = wutils.WifiEnums.channel_5G_to_freq[
- testcase_params['channel']]
+ if testcase_params['channel'] < 13:
+ frequency = wutils.WifiEnums.channel_2G_to_freq[
+ testcase_params['channel']]
+ else:
+ frequency = wutils.WifiEnums.channel_5G_to_freq[
+ testcase_params['channel']]
if frequency in wutils.WifiEnums.DFS_5G_FREQUENCIES:
self.access_point.set_region(self.testbed_params['DFS_region'])
else:
@@ -541,11 +557,13 @@
def setup_dut(self, testcase_params):
"""Sets up the DUT in the configuration required by the test."""
- # Check battery level before test
- if not wputils.health_check(self.dut, 10):
- asserts.skip('Battery level too low. Skipping test.')
# Turn screen off to preserve battery
- self.dut.go_to_sleep()
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
@@ -556,6 +574,8 @@
'channel'] = testcase_params['channel']
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
+ if self.testbed_params.get('txbf_off', False):
+ wputils.disable_beamforming(self.dut)
wutils.wifi_connect(self.dut,
self.main_network[testcase_params['band']],
num_of_tries=5)
@@ -603,6 +623,11 @@
Args:
testcase_params: dict containing test-specific parameters
"""
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
testcase_params.update(
connected_measurements=self.
testclass_params['rssi_vs_atten_connected_measurements'],
@@ -621,14 +646,11 @@
'BSSID', '00:00:00:00')
]
- num_atten_steps = int((self.testclass_params['rssi_vs_atten_stop'] -
- self.testclass_params['rssi_vs_atten_start']) /
- self.testclass_params['rssi_vs_atten_step'])
- testcase_params['rssi_atten_range'] = [
- self.testclass_params['rssi_vs_atten_start'] +
- x * self.testclass_params['rssi_vs_atten_step']
- for x in range(0, num_atten_steps)
- ]
+ testcase_params['rssi_atten_range'] = numpy.arange(
+ self.testclass_params['rssi_vs_atten_start'],
+ self.testclass_params['rssi_vs_atten_stop'],
+ self.testclass_params['rssi_vs_atten_step']).tolist()
+
testcase_params['traffic_timeout'] = self.get_traffic_timeout(
testcase_params)
@@ -646,6 +668,10 @@
Args:
testcase_params: dict containing test-specific parameters
"""
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
testcase_params.update(
connected_measurements=int(
self.testclass_params['rssi_stability_duration'] /
@@ -678,6 +704,11 @@
Args:
testcase_params: dict containing test-specific parameters
"""
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
testcase_params.update(connected_measurements=int(
1 / self.testclass_params['polling_frequency']),
scan_measurements=0,
@@ -787,11 +818,11 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
for channel, mode, traffic_mode, test_type in itertools.product(
@@ -835,9 +866,10 @@
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
- ['test_rssi_stability', 'test_rssi_vs_atten'],
- [1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
- ['bw20', 'bw40', 'bw80'], ['ActiveTraffic'])
+ ['test_rssi_stability', 'test_rssi_vs_atten'], [
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ], ['bw20', 'bw40', 'bw80', 'bw160'], ['ActiveTraffic'])
class WifiRssi_SampleChannels_NoTraffic_Test(WifiRssiTest):
@@ -879,6 +911,7 @@
self.user_params['OTAChamber'])[0]
def teardown_class(self):
+ WifiRssiTest.teardown_class(self)
self.ota_chamber.reset_chamber()
self.process_testclass_results()
@@ -937,7 +970,7 @@
return
plots = []
for channel, channel_data in testclass_data.items():
- current_plot = wputils.BokehFigure(
+ current_plot = BokehFigure(
title='Channel {} - Rssi vs. Position'.format(channel),
x_label=x_label,
primary_y_label='RSSI (dBm)',
@@ -950,7 +983,7 @@
plots.append(current_plot)
current_context = context.get_current_context().get_full_output_path()
plot_file_path = os.path.join(current_context, 'results.html')
- wputils.BokehFigure.save_figures(plots, plot_file_path)
+ BokehFigure.save_figures(plots, plot_file_path)
def setup_rssi_test(self, testcase_params):
# Test setup
@@ -966,22 +999,36 @@
Args:
testcase_params: dict containing test-specific parameters
"""
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
if 'rssi_over_orientation' in self.test_name:
rssi_test_duration = self.testclass_params[
'rssi_over_orientation_duration']
+ rssi_ota_test_attenuation = [
+ self.testclass_params['rssi_ota_test_attenuation']
+ ]
elif 'rssi_variation' in self.test_name:
rssi_test_duration = self.testclass_params[
'rssi_variation_duration']
-
- testcase_params.update(
- connected_measurements=int(
- rssi_test_duration /
- self.testclass_params['polling_frequency']),
- scan_measurements=0,
- first_measurement_delay=MED_SLEEP,
- rssi_atten_range=[
+ rssi_ota_test_attenuation = [
self.testclass_params['rssi_ota_test_attenuation']
- ])
+ ]
+ elif 'rssi_vs_atten' in self.test_name:
+ rssi_test_duration = self.testclass_params[
+ 'rssi_over_orientation_duration']
+ rssi_ota_test_attenuation = numpy.arange(
+ self.testclass_params['rssi_vs_atten_start'],
+ self.testclass_params['rssi_vs_atten_stop'],
+ self.testclass_params['rssi_vs_atten_step']).tolist()
+
+ testcase_params.update(connected_measurements=int(
+ rssi_test_duration / self.testclass_params['polling_frequency']),
+ scan_measurements=0,
+ first_measurement_delay=MED_SLEEP,
+ rssi_atten_range=rssi_ota_test_attenuation)
testcase_params['band'] = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
testcase_params['test_network'] = self.main_network[
@@ -1011,7 +1058,10 @@
self.testclass_results.append(rssi_result)
self.plot_rssi_vs_time(rssi_result,
rssi_result['postprocessed_results'], 1)
- self.plot_rssi_distribution(rssi_result['postprocessed_results'])
+ if 'rssi_vs_atten' in self.test_name:
+ self.plot_rssi_vs_attenuation(rssi_result['postprocessed_results'])
+ elif 'rssi_variation' in self.test_name:
+ self.plot_rssi_distribution(rssi_result['postprocessed_results'])
def generate_test_cases(self, test_types, channels, modes, traffic_modes,
chamber_modes, orientations):
@@ -1019,11 +1069,11 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
for (channel, mode, traffic, chamber_mode, orientation,
@@ -1053,7 +1103,7 @@
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(['test_rssi_vs_atten'],
- [6, 36, 149], ['bw20'],
+ [6, 36, 149, '6g37'], ['bw20'],
['ActiveTraffic'],
['orientation'],
list(range(0, 360, 45)))
@@ -1063,7 +1113,7 @@
def __init__(self, controllers):
WifiRssiTest.__init__(self, controllers)
self.tests = self.generate_test_cases(['test_rssi_variation'],
- [6, 36, 149], ['bw20'],
+ [6, 36, 149, '6g37'], ['bw20'],
['ActiveTraffic'],
['StirrersOn'], [0])
@@ -1072,7 +1122,7 @@
def __init__(self, controllers):
WifiRssiTest.__init__(self, controllers)
self.tests = self.generate_test_cases(['test_rssi_over_orientation'],
- [6, 36, 149], ['bw20'],
+ [6, 36, 149, '6g37'], ['bw20'],
['ActiveTraffic'],
['orientation'],
list(range(0, 360, 10)))
diff --git a/acts_tests/tests/google/wifi/WifiRvrTest.py b/acts_tests/tests/google/wifi/WifiRvrTest.py
index 5096f93..ffa52d5 100644
--- a/acts_tests/tests/google/wifi/WifiRvrTest.py
+++ b/acts_tests/tests/google/wifi/WifiRvrTest.py
@@ -30,6 +30,7 @@
from acts_contrib.test_utils.wifi import ota_chamber
from acts_contrib.test_utils.wifi import ota_sniffer
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 acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from functools import partial
@@ -62,6 +63,7 @@
This function initializes hardwares and compiles parameters that are
common to all tests in this class.
"""
+ self.sta_dut = self.android_devices[0]
req_params = [
'RetailAccessPoints', 'rvr_test_params', 'testbed_params',
'RemoteServer', 'main_network'
@@ -77,7 +79,11 @@
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
if hasattr(self,
'OTASniffer') and self.testbed_params['sniffer_enable']:
- self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
self.log_path = os.path.join(logging.log_path, 'results')
@@ -100,15 +106,18 @@
self.log.info('Turning on airplane mode.')
asserts.assert_true(utils.force_airplane_mode(dev, True),
'Can not turn on airplane mode.')
- wutils.wifi_toggle_state(dev, True)
+ wutils.reset_wifi(dev)
+ wutils.wifi_toggle_state(dev, True)
def teardown_test(self):
self.iperf_server.stop()
def teardown_class(self):
# Turn WiFi OFF
+ self.access_point.teardown()
for dev in self.android_devices:
wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
self.process_testclass_results()
def process_testclass_results(self):
@@ -119,7 +128,7 @@
plot_id = (result['testcase_params']['channel'],
result['testcase_params']['mode'])
if plot_id not in plots:
- plots[plot_id] = wputils.BokehFigure(
+ plots[plot_id] = BokehFigure(
title='Channel {} {} ({})'.format(
result['testcase_params']['channel'],
result['testcase_params']['mode'],
@@ -129,13 +138,20 @@
plots[plot_id].add_line(result['total_attenuation'],
result['throughput_receive'],
result['test_name'],
+ hover_text=result['hover_text'],
marker='circle')
+ plots[plot_id].add_line(result['total_attenuation'],
+ result['avg_phy_rate'],
+ result['test_name'] + ' (PHY)',
+ hover_text=result['hover_text'],
+ marker='circle')
+
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')
- wputils.BokehFigure.save_figures(figure_list, output_file_path)
+ BokehFigure.save_figures(figure_list, output_file_path)
def pass_fail_check(self, rvr_result):
"""Check the test result and decide if it passed or failed.
@@ -242,19 +258,20 @@
data
"""
# Save output as text file
- test_name = self.current_test_name
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(rvr_result, results_file, indent=4)
+ json.dump(wputils.serialize_dict(rvr_result),
+ results_file,
+ indent=4)
# Plot and save
- figure = wputils.BokehFigure(title=test_name,
- x_label='Attenuation (dB)',
- primary_y_label='Throughput (Mbps)')
+ figure = BokehFigure(title=self.current_test_name,
+ x_label='Attenuation (dB)',
+ primary_y_label='Throughput (Mbps)')
try:
golden_path = next(file_name
for file_name in self.golden_files_list
- if test_name in file_name)
+ if self.current_test_name in file_name)
with open(golden_path, 'r') as golden_file:
golden_results = json.load(golden_file)
golden_attenuation = [
@@ -277,23 +294,52 @@
self.log.warning('ValueError: Golden file not found')
# Generate graph annotatios
- hover_text = [
- 'TX MCS = {0} ({1:.1f}%). RX MCS = {2} ({3:.1f}%)'.format(
- curr_llstats['summary']['common_tx_mcs'],
- curr_llstats['summary']['common_tx_mcs_freq'] * 100,
- curr_llstats['summary']['common_rx_mcs'],
- curr_llstats['summary']['common_rx_mcs_freq'] * 100)
- for curr_llstats in rvr_result['llstats']
- ]
+ rvr_result['hover_text'] = {
+ 'llstats': [
+ 'TX MCS = {0} ({1:.1f}%). RX MCS = {2} ({3:.1f}%)'.format(
+ curr_llstats['summary']['common_tx_mcs'],
+ curr_llstats['summary']['common_tx_mcs_freq'] * 100,
+ curr_llstats['summary']['common_rx_mcs'],
+ curr_llstats['summary']['common_rx_mcs_freq'] * 100)
+ for curr_llstats in rvr_result['llstats']
+ ],
+ 'rssi': [
+ '{0:.2f} [{1:.2f},{2:.2f}]'.format(
+ rssi['signal_poll_rssi'],
+ rssi['chain_0_rssi'],
+ rssi['chain_1_rssi'],
+ ) 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'],
- 'Test Results',
- hover_text=hover_text,
+ 'Measured Throughput',
+ hover_text=rvr_result['hover_text'],
color='red',
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')
- output_file_path = os.path.join(self.log_path,
- '{}.html'.format(test_name))
+ 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):
@@ -380,7 +426,7 @@
if self.testbed_params['sniffer_enable']:
self.sniffer.start_capture(
network=testcase_params['test_network'],
- chan=int(testcase_params['channel']),
+ chan=testcase_params['channel'],
bw=testcase_params['bandwidth'],
duration=self.testclass_params['iperf_duration'] / 5)
# Start iperf session
@@ -439,9 +485,7 @@
atten, curr_throughput, current_rssi['signal_poll_rssi'],
current_rssi['chain_0_rssi'],
current_rssi['chain_1_rssi']))
- if curr_throughput == 0 and (
- current_rssi['signal_poll_rssi'] < -80
- or numpy.isnan(current_rssi['signal_poll_rssi'])):
+ if curr_throughput == 0:
zero_counter = zero_counter + 1
else:
zero_counter = 0
@@ -477,20 +521,25 @@
Args:
testcase_params: dict containing AP and other test params
"""
- if '2G' in testcase_params['band']:
- frequency = wutils.WifiEnums.channel_2G_to_freq[
- testcase_params['channel']]
+ band = self.access_point.band_lookup_by_channel(
+ testcase_params['channel'])
+ if '6G' in band:
+ frequency = wutils.WifiEnums.channel_6G_to_freq[int(
+ testcase_params['channel'].strip('6g'))]
else:
- frequency = wutils.WifiEnums.channel_5G_to_freq[
- testcase_params['channel']]
+ if testcase_params['channel'] < 13:
+ frequency = wutils.WifiEnums.channel_2G_to_freq[
+ testcase_params['channel']]
+ else:
+ frequency = wutils.WifiEnums.channel_5G_to_freq[
+ testcase_params['channel']]
if frequency in wutils.WifiEnums.DFS_5G_FREQUENCIES:
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(testcase_params['band'],
- testcase_params['channel'])
- self.access_point.set_bandwidth(testcase_params['band'],
- testcase_params['mode'])
+ self.access_point.set_channel_and_bandwidth(testcase_params['band'],
+ testcase_params['channel'],
+ testcase_params['mode'])
self.log.info('Access Point Configuration: {}'.format(
self.access_point.ap_settings))
@@ -500,24 +549,25 @@
Args:
testcase_params: dict containing AP and other test params
"""
- self.sta_dut = self.android_devices[0]
- # Check battery level before test
- if not wputils.health_check(
- self.sta_dut,
- 20) and testcase_params['traffic_direction'] == 'UL':
- asserts.skip('Overheating or Battery level low. Skipping test.')
# Turn screen off to preserve battery
- self.sta_dut.go_to_sleep()
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.sta_dut.droid.wakeLockAcquireDim()
+ else:
+ self.sta_dut.go_to_sleep()
if wputils.validate_network(self.sta_dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
else:
- wutils.wifi_toggle_state(self.dut, False)
- wutils.set_wifi_country_code(self.dut,
+ wutils.wifi_toggle_state(self.sta_dut, False)
+ wutils.set_wifi_country_code(self.sta_dut,
self.testclass_params['country_code'])
- wutils.wifi_toggle_state(self.dut, True)
- wutils.reset_wifi(self.dut)
- wutils.set_wifi_country_code(self.dut,
+ wutils.wifi_toggle_state(self.sta_dut, True)
+ wutils.reset_wifi(self.sta_dut)
+ if self.testbed_params.get('txbf_off', False):
+ wputils.disable_beamforming(self.sta_dut)
+ wutils.set_wifi_country_code(self.sta_dut,
self.testclass_params['country_code'])
if self.testbed_params['sniffer_enable']:
self.sniffer.start_capture(
@@ -530,6 +580,8 @@
testcase_params['test_network'],
num_of_tries=5,
check_connectivity=True)
+ if self.testclass_params.get('num_streams', 2) == 1:
+ wputils.set_nss_capability(self.sta_dut, 1)
finally:
if self.testbed_params['sniffer_enable']:
self.sniffer.stop_capture(tag='connection_setup')
@@ -569,7 +621,7 @@
self.remote_server, sta_dut_ip, 'public')
# Set DUT to monitor RSSI and LLStats on
self.monitored_dut = self.sta_dut
- self.monitored_interface = None
+ self.monitored_interface = 'wlan0'
def compile_test_params(self, testcase_params):
"""Function that completes all test params based on the test name.
@@ -577,12 +629,18 @@
Args:
testcase_params: dict containing test-specific parameters
"""
- num_atten_steps = int((self.testclass_params['atten_stop'] -
- self.testclass_params['atten_start']) /
- self.testclass_params['atten_step'])
+ # Check if test should be skipped based on parameters.
+ wputils.check_skip_conditions(testcase_params, self.sta_dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
+ band = wputils.CHANNEL_TO_BAND_MAP[testcase_params['channel']]
+ start_atten = self.testclass_params['atten_start'].get(band, 0)
+ num_atten_steps = int(
+ (self.testclass_params['atten_stop'] - start_atten) /
+ self.testclass_params['atten_step'])
testcase_params['atten_range'] = [
- self.testclass_params['atten_start'] +
- x * self.testclass_params['atten_step']
+ start_atten + x * self.testclass_params['atten_step']
for x in range(0, num_atten_steps)
]
band = self.access_point.band_lookup_by_channel(
@@ -649,11 +707,11 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
for channel, mode, traffic_type, traffic_direction in itertools.product(
@@ -678,7 +736,10 @@
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
- channels=[1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
modes=['bw20', 'bw40', 'bw80', 'bw160'],
traffic_types=['TCP'],
traffic_directions=['DL', 'UL'])
@@ -698,7 +759,10 @@
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
- channels=[1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
modes=['HE20', 'HE40', 'HE80', 'HE160'],
traffic_types=['TCP'],
traffic_directions=['DL', 'UL'])
@@ -708,7 +772,7 @@
def __init__(self, controllers):
super().__init__(controllers)
self.tests = self.generate_test_cases(
- channels=[6, 36, 149],
+ channels=[6, 36, 149, '6g37'],
modes=['bw20', 'bw40', 'bw80', 'bw160'],
traffic_types=['UDP'],
traffic_directions=['DL', 'UL'])
@@ -729,7 +793,7 @@
super().__init__(controllers)
self.tests = self.generate_test_cases(
channels=[6, 36, 149],
- modes=['HE20', 'HE40', 'HE80', 'HE160'],
+ modes=['HE20', 'HE40', 'HE80', 'HE160', '6g37'],
traffic_types=['UDP'],
traffic_directions=['DL', 'UL'])
@@ -744,6 +808,57 @@
traffic_directions=['DL', 'UL'])
+class WifiRvr_SingleChain_TCP_Test(WifiRvrTest):
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ self.tests = self.generate_test_cases(
+ channels=[
+ 1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37', '6g117',
+ '6g213'
+ ],
+ modes=['bw20', 'bw40', 'bw80', 'bw160'],
+ traffic_types=['TCP'],
+ traffic_directions=['DL', 'UL'],
+ chains=[0, 1, '2x2'])
+
+ def setup_dut(self, testcase_params):
+ self.sta_dut = self.android_devices[0]
+ wputils.set_chain_mask(self.sta_dut, testcase_params['chain'])
+ WifiRvrTest.setup_dut(self, testcase_params)
+
+ def generate_test_cases(self, channels, modes, traffic_types,
+ traffic_directions, chains):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+ allowed_configs = {
+ 20: [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
+ ],
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
+ }
+
+ for channel, mode, chain, traffic_type, traffic_direction in itertools.product(
+ channels, modes, chains, traffic_types, traffic_directions):
+ bandwidth = int(''.join([x for x in mode if x.isdigit()]))
+ if channel not in allowed_configs[bandwidth]:
+ continue
+ test_name = 'test_rvr_{}_{}_ch{}_{}_ch{}'.format(
+ traffic_type, traffic_direction, channel, mode, chain)
+ test_params = collections.OrderedDict(
+ channel=channel,
+ mode=mode,
+ bandwidth=bandwidth,
+ traffic_type=traffic_type,
+ traffic_direction=traffic_direction,
+ chain=chain)
+ setattr(self, test_name, partial(self._test_rvr, test_params))
+ test_cases.append(test_name)
+ return test_cases
+
+
# Over-the air version of RVR tests
class WifiOtaRvrTest(WifiRvrTest):
"""Class to test over-the-air RvR
@@ -771,7 +886,7 @@
def extract_test_id(self, testcase_params, id_fields):
test_id = collections.OrderedDict(
- (param, testcase_params[param]) for param in id_fields)
+ (param, testcase_params.get(param, None)) for param in id_fields)
return test_id
def process_testclass_results(self):
@@ -781,10 +896,10 @@
compiled_data = collections.OrderedDict()
for result in self.testclass_results:
test_id = tuple(
- self.extract_test_id(
- result['testcase_params'],
- ['channel', 'mode', 'traffic_type', 'traffic_direction'
- ]).items())
+ self.extract_test_id(result['testcase_params'], [
+ 'channel', 'mode', 'traffic_type', 'traffic_direction',
+ 'chain'
+ ]).items())
if test_id not in plots:
# Initialize test id data when not present
compiled_data[test_id] = {'throughput': [], 'metrics': {}}
@@ -792,7 +907,7 @@
key: []
for key in result['metrics'].keys()
}
- plots[test_id] = wputils.BokehFigure(
+ plots[test_id] = BokehFigure(
title='Channel {} {} ({} {})'.format(
result['testcase_params']['channel'],
result['testcase_params']['mode'],
@@ -800,6 +915,15 @@
result['testcase_params']['traffic_direction']),
x_label='Attenuation (dB)',
primary_y_label='Throughput (Mbps)')
+ test_id_phy = test_id + tuple('PHY')
+ plots[test_id_phy] = BokehFigure(
+ title='Channel {} {} ({} {}) (PHY Rate)'.format(
+ result['testcase_params']['channel'],
+ result['testcase_params']['mode'],
+ result['testcase_params']['traffic_type'],
+ result['testcase_params']['traffic_direction']),
+ x_label='Attenuation (dB)',
+ primary_y_label='PHY Rate (Mbps)')
# Compile test id data and metrics
compiled_data[test_id]['throughput'].append(
result['throughput_receive'])
@@ -812,11 +936,19 @@
plots[test_id].add_line(result['total_attenuation'],
result['throughput_receive'],
result['test_name'],
+ 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')
- # Compute average RvRs and compount metrics over orientations
+ # Compute average RvRs and compute metrics over orientations
for test_id, test_data in compiled_data.items():
test_id_dict = dict(test_id)
metric_tag = '{}_{}_ch{}_{}'.format(
@@ -844,17 +976,17 @@
marker='square')
figure_list = []
- for test_id, plot in plots.items():
+ 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')
- wputils.BokehFigure.save_figures(figure_list, output_file_path)
+ BokehFigure.save_figures(figure_list, output_file_path)
def setup_rvr_test(self, testcase_params):
- # Set turntable orientation
- self.ota_chamber.set_orientation(testcase_params['orientation'])
# Continue test setup
WifiRvrTest.setup_rvr_test(self, testcase_params)
+ # Set turntable orientation
+ self.ota_chamber.set_orientation(testcase_params['orientation'])
def generate_test_cases(self, channels, modes, angles, traffic_types,
directions):
@@ -866,7 +998,7 @@
],
40: [36, 44, 100, 149, 157],
80: [36, 100, 149],
- 160: [36]
+ 160: [36, '6g37', '6g117', '6g213']
}
for channel, mode, angle, traffic_type, direction in itertools.product(
channels, modes, angles, traffic_types, directions):
@@ -890,8 +1022,9 @@
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
- [1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161],
- ['bw20', 'bw40', 'bw80'], list(range(0, 360, 45)), ['TCP'], ['DL'])
+ [1, 6, 11, 36, 40, 44, 48, 149, 153, 157, 161, '6g37'],
+ ['bw20', 'bw40', 'bw80', 'bw160'], list(range(0, 360, 45)),
+ ['TCP'], ['DL', 'UL'])
class WifiOtaRvr_SampleChannel_Test(WifiOtaRvrTest):
@@ -901,7 +1034,10 @@
list(range(0, 360, 45)), ['TCP'],
['DL'])
self.tests.extend(
- self.generate_test_cases([36, 149], ['bw80'],
+ self.generate_test_cases([36, 149], ['bw80', 'bw160'],
+ list(range(0, 360, 45)), ['TCP'], ['DL']))
+ self.tests.extend(
+ self.generate_test_cases(['6g37'], ['bw160'],
list(range(0, 360, 45)), ['TCP'], ['DL']))
@@ -909,5 +1045,56 @@
def __init__(self, controllers):
WifiOtaRvrTest.__init__(self, controllers)
self.tests = self.generate_test_cases(
- [6, 36, 40, 44, 48, 149, 153, 157, 161], ['bw20', 'bw40', 'bw80'],
- [0], ['TCP'], ['DL', 'UL'])
+ [6, 36, 40, 44, 48, 149, 153, 157, 161, '6g37'],
+ ['bw20', 'bw40', 'bw80', 'bw160'], [0], ['TCP'], ['DL', 'UL'])
+
+
+class WifiOtaRvr_SingleChain_Test(WifiOtaRvrTest):
+ def __init__(self, controllers):
+ WifiOtaRvrTest.__init__(self, controllers)
+ self.tests = self.generate_test_cases([6], ['bw20'],
+ list(range(0, 360, 45)), ['TCP'],
+ ['DL', 'UL'], [0, 1])
+ self.tests.extend(
+ self.generate_test_cases([36, 149], ['bw20', 'bw80', 'bw160'],
+ list(range(0, 360, 45)), ['TCP'],
+ ['DL', 'UL'], [0, 1, '2x2']))
+ self.tests.extend(
+ self.generate_test_cases(['6g37'], ['bw20', 'bw80', 'bw160'],
+ list(range(0, 360, 45)), ['TCP'],
+ ['DL', 'UL'], [0, 1, '2x2']))
+
+ def setup_dut(self, testcase_params):
+ self.sta_dut = self.android_devices[0]
+ wputils.set_chain_mask(self.sta_dut, testcase_params['chain'])
+ WifiRvrTest.setup_dut(self, testcase_params)
+
+ def generate_test_cases(self, channels, modes, angles, traffic_types,
+ directions, chains):
+ test_cases = []
+ allowed_configs = {
+ 20: [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
+ 116, 132, 140, 149, 153, 157, 161
+ ],
+ 40: [36, 44, 100, 149, 157],
+ 80: [36, 100, 149],
+ 160: [36, '6g37', '6g117', '6g213']
+ }
+ for channel, mode, chain, angle, traffic_type, direction in itertools.product(
+ channels, modes, chains, angles, traffic_types, directions):
+ bandwidth = int(''.join([x for x in mode if x.isdigit()]))
+ if channel not in allowed_configs[bandwidth]:
+ continue
+ testcase_name = 'test_rvr_{}_{}_ch{}_{}_ch{}_{}deg'.format(
+ traffic_type, direction, channel, mode, chain, angle)
+ test_params = collections.OrderedDict(channel=channel,
+ mode=mode,
+ bandwidth=bandwidth,
+ chain=chain,
+ traffic_type=traffic_type,
+ traffic_direction=direction,
+ orientation=angle)
+ setattr(self, testcase_name, partial(self._test_rvr, test_params))
+ test_cases.append(testcase_name)
+ return test_cases
diff --git a/acts_tests/tests/google/wifi/WifiSensitivityTest.py b/acts_tests/tests/google/wifi/WifiSensitivityTest.py
index 41aa32c..954bc90 100644
--- a/acts_tests/tests/google/wifi/WifiSensitivityTest.py
+++ b/acts_tests/tests/google/wifi/WifiSensitivityTest.py
@@ -29,8 +29,10 @@
from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
from acts_contrib.test_utils.wifi import ota_chamber
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 acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
+from acts_contrib.test_utils.wifi import ota_sniffer
from functools import partial
from WifiRvrTest import WifiRvrTest
from WifiPingTest import WifiPingTest
@@ -46,6 +48,7 @@
example_connectivity_performance_ap_sta.json.
"""
+ MAX_CONSECUTIVE_ZEROS = 5
RSSI_POLL_INTERVAL = 0.2
VALID_TEST_CONFIGS = {
1: ['legacy', 'VHT20'],
@@ -138,16 +141,25 @@
common to all tests in this class.
"""
self.dut = self.android_devices[-1]
+ self.sta_dut = self.android_devices[-1]
req_params = [
'RetailAccessPoints', 'sensitivity_test_params', 'testbed_params',
'RemoteServer'
]
- opt_params = ['main_network']
+ opt_params = ['main_network', 'OTASniffer']
self.unpack_userparams(req_params, opt_params)
self.testclass_params = self.sensitivity_test_params
self.num_atten = self.attenuators[0].instrument.num_atten
self.ping_server = ssh.connection.SshConnection(
ssh.settings.from_config(self.RemoteServer[0]['ssh_config']))
+ if hasattr(self,
+ 'OTASniffer') and self.testbed_params['sniffer_enable']:
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
+ self.remote_server = self.ping_server
self.iperf_server = self.iperf_servers[0]
self.iperf_client = self.iperf_clients[0]
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
@@ -169,9 +181,11 @@
self.user_params['retry_tests'] = [self.__class__.__name__]
def teardown_class(self):
+ self.access_point.teardown()
# Turn WiFi OFF
for dev in self.android_devices:
wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
self.process_testclass_results()
def setup_test(self):
@@ -207,9 +221,40 @@
else:
asserts.explicit_pass('Test Passed. {}'.format(result_string))
+ def plot_per_curves(self):
+ """Plots PER curves to help debug sensitivity."""
+
+ plots = collections.OrderedDict()
+ id_fields = ['channel', 'mode', 'num_streams']
+ for result in self.testclass_results:
+ testcase_params = result['testcase_params']
+ plot_id = self.extract_test_id(testcase_params, id_fields)
+ plot_id = tuple(plot_id.items())
+ if plot_id not in plots:
+ plots[plot_id] = BokehFigure(
+ title='Channel {} {} Nss{}'.format(
+ result['testcase_params']['channel'],
+ result['testcase_params']['mode'],
+ result['testcase_params']['num_streams']),
+ x_label='Attenuation (dB)',
+ primary_y_label='PER (%)')
+ per = [stat['summary']['rx_per'] for stat in result['llstats']]
+ if len(per) < len(result['total_attenuation']):
+ per.extend([100] *
+ (len(result['total_attenuation']) - len(per)))
+ plots[plot_id].add_line(result['total_attenuation'], per,
+ result['test_name'])
+ 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_testclass_results(self):
"""Saves and plots test results from all executed test cases."""
# write json output
+ self.plot_per_curves()
testclass_results_dict = collections.OrderedDict()
id_fields = ['mode', 'rate', 'num_streams', 'chain_mask']
channels_tested = []
@@ -331,6 +376,7 @@
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
@@ -386,11 +432,13 @@
Args:
testcase_params: dict containing AP and other test params
"""
- # Check battery level before test
- if not wputils.health_check(self.dut, 10):
- asserts.skip('Battery level too low. Skipping test.')
# Turn screen off to preserve battery
- self.dut.go_to_sleep()
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
if wputils.validate_network(self.dut,
testcase_params['test_network']['SSID']):
self.log.info('Already connected to desired network')
@@ -482,8 +530,14 @@
def compile_test_params(self, testcase_params):
"""Function that generates test params based on the test name."""
+ # Check if test should be skipped.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
+ testcase_params['band'] = band
testcase_params['test_network'] = self.main_network[band]
if testcase_params['chain_mask'] in ['0', '1']:
testcase_params['attenuated_chain'] = 'DUT-Chain-{}'.format(
@@ -675,41 +729,20 @@
testcase_params: dict containing AP and other test params
"""
# Configure the right INI settings
- if testcase_params['chain_mask'] != self.current_chain_mask:
- self.log.info('Updating WiFi chain mask to: {}'.format(
- testcase_params['chain_mask']))
- self.current_chain_mask = testcase_params['chain_mask']
- if testcase_params['chain_mask'] in ['0', '1']:
- wputils.set_ini_single_chain_mode(
- self.dut, int(testcase_params['chain_mask']))
- else:
- wputils.set_ini_two_chain_mode(self.dut)
- # Check battery level before test
- if not wputils.health_check(self.dut, 10):
- asserts.skip('Battery level too low. Skipping test.')
+ wputils.set_chain_mask(self.dut, testcase_params['chain_mask'])
# Turn screen off to preserve battery
- self.dut.go_to_sleep()
- if wputils.validate_network(self.dut,
- testcase_params['test_network']['SSID']):
- self.log.info('Already connected to desired network')
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
else:
- wutils.wifi_toggle_state(self.dut, False)
- wutils.set_wifi_country_code(self.dut,
- self.testclass_params['country_code'])
- wutils.wifi_toggle_state(self.dut, True)
- wutils.reset_wifi(self.dut)
- wutils.set_wifi_country_code(self.dut,
- self.testclass_params['country_code'])
- testcase_params['test_network']['channel'] = testcase_params[
- 'channel']
- wutils.wifi_connect(self.dut,
- testcase_params['test_network'],
- num_of_tries=5,
- check_connectivity=True)
+ self.dut.go_to_sleep()
+ self.validate_and_connect(testcase_params)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def process_testclass_results(self):
"""Saves and plots test results from all executed test cases."""
+ self.plot_per_curves()
testclass_results_dict = collections.OrderedDict()
id_fields = ['channel', 'mode', 'rate']
plots = []
@@ -752,10 +785,9 @@
test_id_str = 'Channel {} - {} MCS{}'.format(
test_id_dict['channel'], test_id_dict['mode'],
test_id_dict['rate'])
- curr_plot = wputils.BokehFigure(
- title=str(test_id_str),
- x_label='Orientation (deg)',
- primary_y_label='Sensitivity (dBm)')
+ curr_plot = BokehFigure(title=str(test_id_str),
+ x_label='Orientation (deg)',
+ primary_y_label='Sensitivity (dBm)')
for line_id, line_results in test_data.items():
curr_plot.add_line(line_results['orientation'],
line_results['sensitivity'],
@@ -784,7 +816,7 @@
curr_plot.generate_figure(output_file_path)
plots.append(curr_plot)
output_file_path = os.path.join(current_context, 'results.html')
- wputils.BokehFigure.save_figures(plots, output_file_path)
+ BokehFigure.save_figures(plots, output_file_path)
def get_start_atten(self, testcase_params):
"""Gets the starting attenuation for this sensitivity test.
@@ -884,8 +916,10 @@
requested_channels = [6, 36, 149]
requested_rates = [
self.RateTuple(8, 1, 86.7),
+ self.RateTuple(6, 1, 65),
self.RateTuple(2, 1, 21.7),
self.RateTuple(8, 2, 173.3),
+ self.RateTuple(6, 2, 130.3),
self.RateTuple(2, 2, 43.3)
]
self.tests = self.generate_test_cases(requested_channels,
@@ -899,12 +933,16 @@
WifiOtaSensitivityTest.__init__(self, controllers)
requested_channels = [6, 36, 149]
requested_rates = [
+ self.RateTuple(9, 1, 96),
+ self.RateTuple(9, 2, 192),
+ self.RateTuple(6, 1, 65),
+ self.RateTuple(6, 2, 130.3),
self.RateTuple(2, 1, 21.7),
self.RateTuple(2, 2, 43.3)
]
- self.tests = self.generate_test_cases(requested_channels, ['VHT20'],
- requested_rates,
- ['0', '1', '2x2'],
+ self.tests = self.generate_test_cases(requested_channels,
+ ['VHT20', 'VHT80'],
+ requested_rates, [0, 1, '2x2'],
list(range(0, 360, 10)))
diff --git a/acts_tests/tests/google/wifi/WifiSoftApPerformanceTest.py b/acts_tests/tests/google/wifi/WifiSoftApPerformanceTest.py
index b116666..47719c5 100644
--- a/acts_tests/tests/google/wifi/WifiSoftApPerformanceTest.py
+++ b/acts_tests/tests/google/wifi/WifiSoftApPerformanceTest.py
@@ -64,7 +64,6 @@
opt_params = ['golden_files_list', 'OTASniffer']
self.unpack_userparams(req_params, opt_params)
self.access_points = retail_ap.create(self.RetailAccessPoints)
- self.access_point = self.access_points[0]
self.testclass_params = self.sap_test_params
self.num_atten = self.attenuators[0].instrument.num_atten
self.iperf_server = ipf.create([{
@@ -81,7 +80,11 @@
}])[0]
if hasattr(self,
'OTASniffer') and self.testbed_params['sniffer_enable']:
- self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
self.log_path = os.path.join(logging.log_path, 'results')
os.makedirs(self.log_path, exist_ok=True)
@@ -106,9 +109,11 @@
wutils.stop_wifi_tethering(self.android_devices[0])
for dev in self.android_devices:
wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
self.process_testclass_results()
# Teardown AP and release it's lockfile
- self.access_point.teardown()
+ for ap in self.access_points:
+ ap.teardown()
def teardown_test(self):
self.iperf_server.stop()
@@ -118,13 +123,17 @@
info = {}
info['client_ip_address'] = self.android_devices[
1].droid.connectivityGetIPv4Addresses('wlan0')[0]
+ ifconfig_out = self.android_devices[0].adb.shell('ifconfig')
+ soft_ap_interface = 'wlan1' if 'wlan1' in ifconfig_out else 'wlan2'
info['ap_ip_address'] = self.android_devices[
- 0].droid.connectivityGetIPv4Addresses('wlan1')[0]
- info['frequency'] = self.android_devices[1].adb.shell(
- 'wpa_cli status | grep freq').split('=')[1]
+ 0].droid.connectivityGetIPv4Addresses(soft_ap_interface)[0]
+
+ connection_rssi = wputils.get_connected_rssi(self.android_devices[1],
+ interface='wlan0')
+ info['frequency'] = connection_rssi['frequency'][0]
info['channel'] = wutils.WifiEnums.freq_to_channel[int(
info['frequency'])]
- info['mode'] = 'VHT20' if info['channel'] < 13 else 'VHT80'
+ info['mode'] = 'bw20' if info['channel'] < 13 else 'bw80'
return info
def setup_aps(self, testcase_params):
@@ -180,11 +189,23 @@
num_of_tries=5,
check_connectivity=False)
# Compile meta data
- #self.access_point = AccessPointTuple(sap_config)
sap_info = self.get_sap_connection_info()
print("SAP Info: {}".format(sap_info))
testcase_params['channel'] = sap_info['channel']
+ if testcase_params['channel'] < 13:
+ testcase_params['band'] = '2GHz'
+ else:
+ testcase_params['band'] = '5GHz'
testcase_params['mode'] = sap_info['mode']
+ self.access_point = AccessPointTuple({
+ testcase_params['band']: {
+ 'SSID': sap_config[wutils.WifiEnums.SSID_KEY],
+ 'password': sap_config[wutils.WifiEnums.PWD_KEY],
+ 'channel': sap_info['channel'],
+ 'mode': sap_info['mode'],
+ 'bandwidth': sap_info['mode'],
+ }
+ })
testcase_params['iperf_server_address'] = sap_info['ap_ip_address']
def setup_sap_rvr_test(self, testcase_params):
@@ -204,7 +225,7 @@
self.setup_sap_connection(testcase_params)
# Set DUT to monitor RSSI and LLStats on
self.monitored_dut = self.sta_dut
- self.monitored_interface = None
+ self.monitored_interface = 'wlan0'
def compile_test_params(self, testcase_params):
"""Function that completes all test params based on the test name.
diff --git a/acts_tests/tests/google/wifi/WifiTdlsRvrTest.py b/acts_tests/tests/google/wifi/WifiTdlsRvrTest.py
new file mode 100644
index 0000000..b051448
--- /dev/null
+++ b/acts_tests/tests/google/wifi/WifiTdlsRvrTest.py
@@ -0,0 +1,365 @@
+#!/usr/bin/env python3.4
+#
+# 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 collections
+import itertools
+import logging
+import os
+from acts import asserts
+from acts import base_test
+from acts import utils
+from acts.controllers import iperf_server as ipf
+from acts.controllers import iperf_client as ipc
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts.test_decorators import test_tracker_info
+from acts_contrib.test_utils.wifi import ota_sniffer
+from acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from functools import partial
+from WifiRvrTest import WifiRvrTest
+
+AccessPointTuple = collections.namedtuple(('AccessPointTuple'),
+ ['ap_settings'])
+
+
+class WifiTdlsRvrTest(WifiRvrTest):
+ 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.
+ """
+ req_params = [
+ 'tdls_rvr_test_params', 'testbed_params', 'RetailAccessPoints'
+ ]
+ opt_params = ['ap_networks', 'OTASniffer']
+ self.unpack_userparams(req_params, opt_params)
+ self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
+ self.testclass_params = self.tdls_rvr_test_params
+ self.num_atten = self.attenuators[0].instrument.num_atten
+ self.iperf_server = ipf.create([{
+ 'AndroidDevice':
+ self.android_devices[0].serial,
+ 'port':
+ '5201'
+ }])[0]
+ self.iperf_client = ipc.create([{
+ 'AndroidDevice':
+ self.android_devices[1].serial,
+ 'port':
+ '5201'
+ }])[0]
+
+ self.log_path = os.path.join(logging.log_path, 'results')
+ if hasattr(self,
+ 'OTASniffer') and self.testbed_params['sniffer_enable']:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ os.makedirs(self.log_path, exist_ok=True)
+ if not hasattr(self, 'golden_files_list'):
+ if 'golden_results_path' in self.testbed_params:
+ self.golden_files_list = [
+ os.path.join(self.testbed_params['golden_results_path'],
+ file) for file in
+ os.listdir(self.testbed_params['golden_results_path'])
+ ]
+ else:
+ self.log.warning('No golden files found.')
+ self.golden_files_list = []
+
+ self.testclass_results = []
+
+ # Turn WiFi ON
+ if self.testclass_params.get('airplane_mode', 1):
+ self.log.info('Turning on airplane mode.')
+ for ad in self.android_devices:
+ asserts.assert_true(utils.force_airplane_mode(ad, True),
+ "Can not turn on airplane mode.")
+ for ad in self.android_devices:
+ wutils.wifi_toggle_state(ad, True)
+
+ def teardown_class(self):
+ # Turn WiFi OFF
+ for dev in self.android_devices:
+ wutils.wifi_toggle_state(dev, False)
+ self.process_testclass_results()
+ # Teardown AP and release its lockfile
+ self.access_point.teardown()
+
+ def setup_test(self):
+ for ad in self.android_devices:
+ wputils.start_wifi_logging(ad)
+
+ def teardown_test(self):
+ self.iperf_server.stop()
+ for ad in self.android_devices:
+ wutils.reset_wifi(ad)
+ wputils.stop_wifi_logging(ad)
+
+ def on_exception(self, test_name, begin_time):
+ for ad in self.android_devices:
+ ad.take_bug_report(test_name, begin_time)
+ ad.cat_adb_log(test_name, begin_time)
+ wutils.get_ssrdumps(ad)
+
+ def compute_test_metrics(self, rvr_result):
+ #Set test metrics
+ rvr_result['metrics'] = {}
+ rvr_result['metrics']['peak_tput'] = max(
+ rvr_result['throughput_receive'])
+ if self.publish_testcase_metrics:
+ self.testcase_metric_logger.add_metric(
+ 'peak_tput', rvr_result['metrics']['peak_tput'])
+
+ test_mode = rvr_result['testcase_params']['mode']
+ tput_below_limit = [
+ tput <
+ self.testclass_params['tput_metric_targets'][test_mode]['high']
+ for tput in rvr_result['throughput_receive']
+ ]
+ rvr_result['metrics']['high_tput_range'] = -1
+ for idx in range(len(tput_below_limit)):
+ if all(tput_below_limit[idx:]):
+ if idx == 0:
+ #Throughput was never above limit
+ rvr_result['metrics']['high_tput_range'] = -1
+ else:
+ rvr_result['metrics']['high_tput_range'] = rvr_result[
+ 'total_attenuation'][max(idx, 1) - 1]
+ break
+ if self.publish_testcase_metrics:
+ self.testcase_metric_logger.add_metric(
+ 'high_tput_range', rvr_result['metrics']['high_tput_range'])
+
+ tput_below_limit = [
+ tput <
+ self.testclass_params['tput_metric_targets'][test_mode]['low']
+ for tput in rvr_result['throughput_receive']
+ ]
+ for idx in range(len(tput_below_limit)):
+ if all(tput_below_limit[idx:]):
+ rvr_result['metrics']['low_tput_range'] = rvr_result[
+ 'total_attenuation'][max(idx, 1) - 1]
+ break
+ else:
+ rvr_result['metrics']['low_tput_range'] = -1
+ if self.publish_testcase_metrics:
+ self.testcase_metric_logger.add_metric(
+ 'low_tput_range', rvr_result['metrics']['low_tput_range'])
+
+ def setup_aps(self, testcase_params):
+ self.log.info('Setting AP to channel {} {}'.format(
+ testcase_params['channel'], testcase_params['bandwidth']))
+ self.access_point.set_channel(testcase_params['interface_id'],
+ testcase_params['channel'])
+ self.access_point.set_bandwidth(testcase_params['interface_id'],
+ testcase_params['bandwidth'])
+
+ def setup_duts(self, testcase_params):
+ # Check battery level before test
+ for ad in self.android_devices:
+ if not wputils.health_check(ad, 20):
+ asserts.skip('Overheating or Battery low. Skipping test.')
+ ad.go_to_sleep()
+ wutils.reset_wifi(ad)
+ # Turn screen off to preserve battery
+ for ad in self.android_devices:
+ wutils.wifi_connect(
+ ad,
+ self.ap_networks[0][testcase_params['interface_id']],
+ num_of_tries=5,
+ check_connectivity=True)
+
+ def setup_tdls_connection(self, testcase_params):
+
+ tdls_config = {}
+ for idx, ad in enumerate(self.android_devices):
+ tdls_config[idx] = {
+ 'ip_address':
+ ad.droid.connectivityGetIPv4Addresses('wlan0')[0],
+ 'mac_address': ad.droid.wifiGetConnectionInfo()['mac_address'],
+ 'tdls_supported': ad.droid.wifiIsTdlsSupported(),
+ 'off_channel_supported':
+ ad.droid.wifiIsOffChannelTdlsSupported()
+ }
+ self.android_devices[0].droid.wifiSetTdlsEnabledWithMacAddress(
+ tdls_config[1]['mac_address'], True)
+
+ testcase_params['iperf_server_address'] = tdls_config[0]['ip_address']
+ testcase_params['tdls_config'] = tdls_config
+ testcase_params['channel'] = testcase_params['channel']
+ testcase_params['mode'] = testcase_params['bandwidth']
+ testcase_params['test_network'] = self.ap_networks[0][
+ testcase_params['interface_id']]
+
+ def setup_tdls_rvr_test(self, testcase_params):
+ # Setup the aps
+ self.setup_aps(testcase_params)
+ # Setup the duts
+ self.setup_duts(testcase_params)
+ # Set attenuator to 0 dB
+ for attenuator in self.attenuators:
+ attenuator.set_atten(0, strict=False)
+ # Setup the aware connection
+ self.setup_tdls_connection(testcase_params)
+ # Set DUT to monitor RSSI and LLStats on
+ self.monitored_dut = self.android_devices[1]
+
+ 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
+ """
+ for ad in self.android_devices:
+ wputils.check_skip_conditions(testcase_params, ad,
+ self.access_point)
+
+ # Compile RvR parameters
+ num_atten_steps = int((self.testclass_params['atten_stop'] -
+ self.testclass_params['atten_start']) /
+ self.testclass_params['atten_step'])
+ testcase_params['atten_range'] = [
+ self.testclass_params['atten_start'] +
+ x * self.testclass_params['atten_step']
+ for x in range(0, num_atten_steps)
+ ]
+
+ # Compile iperf arguments
+ if testcase_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 testcase_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)
+ testcase_params['iperf_args'] = wputils.get_iperf_arg_string(
+ duration=self.testclass_params['iperf_duration'],
+ reverse_direction=(testcase_params['traffic_direction'] == 'DL'),
+ socket_size=testcase_params['iperf_socket_size'],
+ num_processes=testcase_params['iperf_processes'],
+ traffic_type=testcase_params['traffic_type'],
+ ipv6=False)
+ testcase_params['use_client_output'] = (
+ testcase_params['traffic_direction'] == 'DL')
+
+ # Compile AP and infrastructure connection parameters
+ testcase_params['interface_id'] = '2G' if testcase_params[
+ 'channel'] < 13 else '5G_1'
+ return testcase_params
+
+ def _test_tdls_rvr(self, testcase_params):
+ """ Function that gets called for each test case
+
+ Args:
+ testcase_params: dict containing test-specific parameters
+ """
+ # Compile test parameters from config and test name
+ testcase_params = self.compile_test_params(testcase_params)
+
+ # Prepare devices and run test
+ self.setup_tdls_rvr_test(testcase_params)
+ rvr_result = self.run_rvr_test(testcase_params)
+
+ # Post-process results
+ self.testclass_results.append(rvr_result)
+ self.process_test_results(rvr_result)
+ self.pass_fail_check(rvr_result)
+
+ def generate_test_cases(self, ap_config_list, traffic_type,
+ traffic_directions):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+
+ for ap_config, traffic_direction in itertools.product(
+ ap_config_list, traffic_directions):
+ test_name = 'test_tdls_rvr_{}_{}_ch{}_{}'.format(
+ traffic_type, traffic_direction, ap_config[0], ap_config[1])
+ test_params = collections.OrderedDict(
+ traffic_type=traffic_type,
+ traffic_direction=traffic_direction,
+ channel=ap_config[0],
+ bandwidth=ap_config[1])
+ test_class = self.__class__.__name__
+ if "uuid_list" in self.user_params:
+ test_tracker_uuid = self.user_params["uuid_list"][
+ test_class][test_name]
+ test_case = test_tracker_info(uuid=test_tracker_uuid)(
+ lambda: self._test_tdls_rvr(test_params))
+ else:
+ test_case = partial(self._test_tdls_rvr,test_params)
+ setattr(self, test_name, test_case)
+ test_cases.append(test_name)
+ return test_cases
+
+
+class WifiTdlsRvr_FCC_TCP_Test(WifiTdlsRvrTest):
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ ap_config_list = [[6, 'bw20'], [36, 'bw20'], [36, 'bw40'],
+ [36, 'bw80'], [149, 'bw20'], [149, 'bw40'],
+ [149, 'bw80']]
+ self.country_code = 'US'
+ self.tests = self.generate_test_cases(ap_config_list=ap_config_list,
+ traffic_type='TCP',
+ traffic_directions=['DL', 'UL'])
+
+
+class WifiTdlsRvr_FCC_UDP_Test(WifiTdlsRvrTest):
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ ap_config_list = [[6, 'bw20'], [36, 'bw20'], [36, 'bw40'],
+ [36, 'bw80'], [149, 'bw20'], [149, 'bw40'],
+ [149, 'bw80']]
+ self.country_code = 'US'
+ self.tests = self.generate_test_cases(ap_config_list=ap_config_list,
+ traffic_type='UDP',
+ traffic_directions=['DL', 'UL'])
+
+
+class WifiTdlsRvr_ETSI_TCP_Test(WifiTdlsRvrTest):
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ ap_config_list = [[6, 'bw20'], [36, 'bw20'], [36, 'bw40'],
+ [36, 'bw80'], [149, 'bw20'], [149, 'bw40'],
+ [149, 'bw80']]
+ self.country_code = 'GB'
+ self.tests = self.generate_test_cases(ap_config_list=ap_config_list,
+ traffic_type='TCP',
+ traffic_directions=['DL', 'UL'])
+
+
+class WifiTdlsRvr_ETSI_UDP_Test(WifiTdlsRvrTest):
+ def __init__(self, controllers):
+ super().__init__(controllers)
+ ap_config_list = [[6, 'bw20'], [36, 'bw20'], [36, 'bw40'],
+ [36, 'bw80'], [149, 'bw20'], [149, 'bw40'],
+ [149, 'bw80']]
+ self.country_code = 'GB'
+ self.tests = self.generate_test_cases(ap_config_list=ap_config_list,
+ traffic_type='UDP',
+ traffic_directions=['DL', 'UL'])
diff --git a/acts_tests/tests/google/wifi/WifiTeleCoexTest.py b/acts_tests/tests/google/wifi/WifiTeleCoexTest.py
index 02e9541..3031627 100644
--- a/acts_tests/tests/google/wifi/WifiTeleCoexTest.py
+++ b/acts_tests/tests/google/wifi/WifiTeleCoexTest.py
@@ -17,6 +17,7 @@
from acts_contrib.test_utils.tel.tel_ims_utils import set_wfc_mode
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_voice_general
from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phones_idle
+from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_network_generation
from acts_contrib.test_utils.tel.tel_voice_utils import two_phone_call_short_seq
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_iwlan
@@ -212,7 +213,7 @@
"""
tele_utils.toggle_airplane_mode(self.log, self.android_devices[0], False)
toggle_volte(self.log, self.android_devices[0], volte_mode)
- if not tele_utils.ensure_network_generation(
+ if not ensure_network_generation(
self.log,
self.android_devices[0],
GEN_4G,
diff --git a/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py b/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
index 59c8575..a8d9628 100644
--- a/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
+++ b/acts_tests/tests/google/wifi/WifiThroughputStabilityTest.py
@@ -29,7 +29,9 @@
from acts.controllers.utils_lib import ssh
from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
from acts_contrib.test_utils.wifi import ota_chamber
+from acts_contrib.test_utils.wifi import ota_sniffer
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 acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
from functools import partial
@@ -57,10 +59,9 @@
BlackboxMappedMetricLogger.for_test_class())
self.publish_testcase_metrics = True
# Generate test cases
- self.tests = self.generate_test_cases([6, 36, 149],
- ['bw20', 'bw40', 'bw80'],
- ['TCP', 'UDP'], ['DL', 'UL'],
- ['high', 'low'])
+ self.tests = self.generate_test_cases(
+ [6, 36, 149, '6g37'], ['bw20', 'bw40', 'bw80', 'bw160'],
+ ['TCP', 'UDP'], ['DL', 'UL'], ['high', 'low'])
def generate_test_cases(self, channels, modes, traffic_types,
traffic_directions, signal_levels):
@@ -68,11 +69,11 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
test_cases = []
@@ -108,7 +109,8 @@
'throughput_stability_test_params', 'testbed_params',
'main_network', 'RetailAccessPoints', 'RemoteServer'
]
- self.unpack_userparams(req_params)
+ opt_params = ['OTASniffer']
+ self.unpack_userparams(req_params, opt_params)
self.testclass_params = self.throughput_stability_test_params
self.num_atten = self.attenuators[0].instrument.num_atten
self.remote_server = ssh.connection.SshConnection(
@@ -116,6 +118,13 @@
self.iperf_server = self.iperf_servers[0]
self.iperf_client = self.iperf_clients[0]
self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
+ if hasattr(self,
+ 'OTASniffer') and self.testbed_params['sniffer_enable']:
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
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(
@@ -133,7 +142,14 @@
def teardown_test(self):
self.iperf_server.stop()
- def pass_fail_check(self, test_result_dict):
+ def teardown_class(self):
+ self.access_point.teardown()
+ # Turn WiFi OFF
+ for dev in self.android_devices:
+ wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
+
+ def pass_fail_check(self, test_result):
"""Check the test result and decide if it passed or failed.
Checks the throughput stability test's PASS/FAIL criteria based on
@@ -143,11 +159,11 @@
test_result_dict: dict containing attenuation, throughput and other
meta data
"""
- avg_throughput = test_result_dict['iperf_results']['avg_throughput']
- min_throughput = test_result_dict['iperf_results']['min_throughput']
+ avg_throughput = test_result['iperf_summary']['avg_throughput']
+ min_throughput = test_result['iperf_summary']['min_throughput']
std_dev_percent = (
- test_result_dict['iperf_results']['std_deviation'] /
- test_result_dict['iperf_results']['avg_throughput']) * 100
+ 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',
@@ -163,13 +179,21 @@
std_deviation_check = 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_dict['attenuation'],
- test_result_dict['rssi'], avg_throughput,
- std_dev_percent, min_throughput,
- test_result_dict['llstats']))
+ '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)
@@ -188,18 +212,6 @@
test_name = self.current_test_name
results_file_path = os.path.join(self.log_path,
'{}.txt'.format(test_name))
- test_result_dict = {}
- test_result_dict['ap_settings'] = test_result['ap_settings'].copy()
- test_result_dict['attenuation'] = test_result['attenuation']
- test_result_dict['rssi'] = test_result['rssi_result'][
- 'signal_poll_rssi']['mean']
- test_result_dict['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))
if test_result['iperf_result'].instantaneous_rates:
instantaneous_rates_Mbps = [
rate * 8 * (1.024**2)
@@ -210,20 +222,20 @@
'iperf_result'].get_std_deviation(
self.testclass_params['iperf_ignored_interval']) * 8
else:
- instantaneous_rates_Mbps = float('nan')
+ instantaneous_rates_Mbps = [float('nan')]
tput_standard_deviation = float('nan')
- test_result_dict['iperf_results'] = {
+ 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)
}
with open(results_file_path, 'w') as results_file:
- json.dump(test_result_dict, results_file)
+ json.dump(wputils.serialize_dict(test_result), results_file)
# Plot and save
- figure = wputils.BokehFigure(test_name,
- x_label='Time (s)',
- primary_y_label='Throughput (Mbps)')
+ 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,
@@ -232,7 +244,7 @@
output_file_path = os.path.join(self.log_path,
'{}.html'.format(test_name))
figure.generate_figure(output_file_path)
- return test_result_dict
+ return test_result
def setup_ap(self, testcase_params):
"""Sets up the access point in the configuration required by the test.
@@ -242,12 +254,16 @@
"""
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
- if '2G' in band:
- frequency = wutils.WifiEnums.channel_2G_to_freq[
- testcase_params['channel']]
+ if '6G' in band:
+ frequency = wutils.WifiEnums.channel_6G_to_freq[int(
+ testcase_params['channel'].strip('6g'))]
else:
- frequency = wutils.WifiEnums.channel_5G_to_freq[
- testcase_params['channel']]
+ if testcase_params['channel'] < 13:
+ frequency = wutils.WifiEnums.channel_2G_to_freq[
+ testcase_params['channel']]
+ else:
+ frequency = wutils.WifiEnums.channel_5G_to_freq[
+ testcase_params['channel']]
if frequency in wutils.WifiEnums.DFS_5G_FREQUENCIES:
self.access_point.set_region(self.testbed_params['DFS_region'])
else:
@@ -263,11 +279,13 @@
Args:
testcase_params: dict containing AP and other test params
"""
- # Check battery level before test
- if not wputils.health_check(self.dut, 10):
- asserts.skip('Battery level too low. Skipping test.')
# Turn screen off to preserve battery
- self.dut.go_to_sleep()
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
if wputils.validate_network(self.dut,
@@ -276,13 +294,15 @@
else:
wutils.wifi_toggle_state(self.dut, True)
wutils.reset_wifi(self.dut)
+ if self.testbed_params.get('txbf_off', False):
+ wputils.disable_beamforming(self.dut)
wutils.set_wifi_country_code(self.dut,
self.testclass_params['country_code'])
self.main_network[band]['channel'] = testcase_params['channel']
wutils.wifi_connect(self.dut,
testcase_params['test_network'],
num_of_tries=5,
- check_connectivity=False)
+ check_connectivity=True)
self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
def setup_throughput_stability_test(self, testcase_params):
@@ -293,6 +313,9 @@
"""
# Configure AP
self.setup_ap(testcase_params)
+ # Set attenuator to 0 dB
+ for attenuator in self.attenuators:
+ attenuator.set_atten(0, strict=False, retry=True)
# Reset, configure, and connect DUT
self.setup_dut(testcase_params)
# Wait before running the first wifi test
@@ -331,6 +354,12 @@
self.log.info('Starting iperf test.')
llstats_obj = wputils.LinkLayerStats(self.dut)
llstats_obj.update_stats()
+ if self.testbed_params['sniffer_enable']:
+ self.sniffer.start_capture(
+ network=testcase_params['test_network'],
+ chan=testcase_params['channel'],
+ bw=testcase_params['bandwidth'],
+ duration=self.testclass_params['iperf_duration'] / 5)
self.iperf_server.start(tag=str(testcase_params['atten_level']))
current_rssi = wputils.get_connected_rssi_nb(
dut=self.dut,
@@ -345,6 +374,9 @@
self.testclass_params['iperf_duration'] + TEST_TIMEOUT)
current_rssi = current_rssi.result()
server_output_path = self.iperf_server.stop()
+ # Stop sniffer
+ if self.testbed_params['sniffer_enable']:
+ self.sniffer.stop_capture()
# Set attenuator to 0 dB
for attenuator in self.attenuators:
attenuator.set_atten(0)
@@ -389,9 +421,9 @@
# Get attenuation for target RSSI
if testcase_params['signal_level'] == 'low':
- target_rssi = self.testclass_params['low_throughput_target']
+ target_rssi = self.testclass_params['low_throughput_rssi_target']
else:
- target_rssi = self.testclass_params['high_throughput_target']
+ target_rssi = self.testclass_params['high_throughput_rssi_target']
target_atten = wputils.get_atten_for_target_rssi(
target_rssi, self.attenuators, self.dut, self.remote_server)
@@ -400,6 +432,11 @@
def compile_test_params(self, testcase_params):
"""Function that completes setting the test case parameters."""
+ # Check if test should be skipped based on parameters.
+ wputils.check_skip_conditions(testcase_params, self.dut,
+ self.access_point,
+ getattr(self, 'ota_chamber', None))
+
band = self.access_point.band_lookup_by_channel(
testcase_params['channel'])
testcase_params['test_network'] = self.main_network[band]
@@ -423,7 +460,9 @@
reverse_direction=1,
traffic_type=testcase_params['traffic_type'],
socket_size=testcase_params['iperf_socket_size'],
- num_processes=testcase_params['iperf_processes'])
+ num_processes=testcase_params['iperf_processes'],
+ udp_throughput=self.testclass_params['UDP_rates'][
+ testcase_params['mode']])
testcase_params['use_client_output'] = True
else:
testcase_params['iperf_args'] = wputils.get_iperf_arg_string(
@@ -431,7 +470,9 @@
reverse_direction=0,
traffic_type=testcase_params['traffic_type'],
socket_size=testcase_params['iperf_socket_size'],
- num_processes=testcase_params['iperf_processes'])
+ num_processes=testcase_params['iperf_processes'],
+ udp_throughput=self.testclass_params['UDP_rates'][
+ testcase_params['mode']])
testcase_params['use_client_output'] = False
return testcase_params
@@ -475,6 +516,7 @@
self.user_params['OTAChamber'])[0]
def teardown_class(self):
+ WifiThroughputStabilityTest.teardown_class(self)
self.ota_chamber.reset_chamber()
self.process_testclass_results()
@@ -496,12 +538,9 @@
]).items())
test_data = channel_data.setdefault(
test_id, collections.OrderedDict(position=[], throughput=[]))
- current_throughput = (numpy.mean(
- test['iperf_result'].instantaneous_rates[
- self.testclass_params['iperf_ignored_interval']:-1])
- ) * 8 * (1.024**2)
test_data['position'].append(current_params['position'])
- test_data['throughput'].append(current_throughput)
+ test_data['throughput'].append(
+ test['iperf_summary']['avg_throughput'])
chamber_mode = self.testclass_results[0]['testcase_params'][
'chamber_mode']
@@ -519,7 +558,7 @@
test_id_dict['traffic_direction'], channel,
test_id_dict['mode'])
metric_name = metric_tag + '.avg_throughput'
- metric_value = numpy.mean(test_data['throughput'])
+ metric_value = numpy.nanmean(test_data['throughput'])
self.testclass_metric_logger.add_metric(
metric_name, metric_value)
metric_name = metric_tag + '.min_throughput'
@@ -530,7 +569,7 @@
# Plot test class results
plots = []
for channel, channel_data in testclass_data.items():
- current_plot = wputils.BokehFigure(
+ current_plot = BokehFigure(
title='Channel {} - Rate vs. Position'.format(channel),
x_label=x_label,
primary_y_label='Rate (Mbps)',
@@ -547,7 +586,7 @@
plots.append(current_plot)
current_context = context.get_current_context().get_full_output_path()
plot_file_path = os.path.join(current_context, 'results.html')
- wputils.BokehFigure.save_figures(plots, plot_file_path)
+ BokehFigure.save_figures(plots, plot_file_path)
def setup_throughput_stability_test(self, testcase_params):
WifiThroughputStabilityTest.setup_throughput_stability_test(
@@ -559,10 +598,11 @@
self.ota_chamber.step_stirrers(testcase_params['total_positions'])
def get_target_atten(self, testcase_params):
+ band = wputils.CHANNEL_TO_BAND_MAP[testcase_params['channel']]
if testcase_params['signal_level'] == 'high':
- test_atten = self.testclass_params['default_atten_levels'][0]
+ test_atten = self.testclass_params['ota_atten_levels'][band][0]
elif testcase_params['signal_level'] == 'low':
- test_atten = self.testclass_params['default_atten_levels'][1]
+ test_atten = self.testclass_params['ota_atten_levels'][band][1]
return test_atten
def generate_test_cases(self, channels, modes, traffic_types,
@@ -571,16 +611,16 @@
allowed_configs = {
20: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 64, 100,
- 116, 132, 140, 149, 153, 157, 161
+ 116, 132, 140, 149, 153, 157, 161, '6g37', '6g117', '6g213'
],
- 40: [36, 44, 100, 149, 157],
- 80: [36, 100, 149],
- 160: [36]
+ 40: [36, 44, 100, 149, 157, '6g37', '6g117', '6g213'],
+ 80: [36, 100, 149, '6g37', '6g117', '6g213'],
+ 160: [36, '6g37', '6g117', '6g213']
}
test_cases = []
- for channel, mode, position, traffic_type, signal_level, traffic_direction in itertools.product(
- channels, modes, positions, traffic_types, signal_levels,
+ for channel, mode, signal_level, position, traffic_type, traffic_direction in itertools.product(
+ channels, modes, signal_levels, positions, traffic_types,
traffic_directions):
bandwidth = int(''.join([x for x in mode if x.isdigit()]))
if channel not in allowed_configs[bandwidth]:
@@ -588,6 +628,7 @@
testcase_params = collections.OrderedDict(
channel=channel,
mode=mode,
+ bandwidth=bandwidth,
traffic_type=traffic_type,
traffic_direction=traffic_direction,
signal_level=signal_level,
@@ -608,7 +649,8 @@
):
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
- self.tests = self.generate_test_cases([6, 36, 149], ['bw20', 'bw80'],
+ self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
+ ['bw20', 'bw80', 'bw160'],
['TCP'], ['DL', 'UL'],
['high', 'low'], 'orientation',
list(range(0, 360, 10)))
@@ -617,7 +659,8 @@
class WifiOtaThroughputStability_45Degree_Test(WifiOtaThroughputStabilityTest):
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
- self.tests = self.generate_test_cases([6, 36, 149], ['bw20', 'bw80'],
+ self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
+ ['bw20', 'bw80', 'bw160'],
['TCP'], ['DL', 'UL'],
['high', 'low'], 'orientation',
list(range(0, 360, 45)))
@@ -627,8 +670,9 @@
WifiOtaThroughputStabilityTest):
def __init__(self, controllers):
WifiOtaThroughputStabilityTest.__init__(self, controllers)
- self.tests = self.generate_test_cases([6, 36, 149], ['bw20', 'bw80'],
+ self.tests = self.generate_test_cases([6, 36, 149, '6g37'],
+ ['bw20', 'bw80', 'bw160'],
['TCP'], ['DL', 'UL'],
['high', 'low'],
'stepped stirrers',
- list(range(100)))
\ No newline at end of file
+ list(range(100)))
diff --git a/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py b/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py
new file mode 100644
index 0000000..706903c
--- /dev/null
+++ b/acts_tests/tests/google/wifi/WifiTxPowerCheckTest.py
@@ -0,0 +1,927 @@
+#!/usr/bin/env python3.4
+#
+# 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 collections
+import csv
+import itertools
+import json
+import logging
+import math
+import os
+import re
+import scipy.stats
+import time
+from acts import asserts
+from acts import context
+from acts import base_test
+from acts import utils
+from acts.controllers.utils_lib import ssh
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts_contrib.test_utils.wifi import ota_sniffer
+from acts_contrib.test_utils.wifi import wifi_performance_test_utils as wputils
+from acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
+from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
+from functools import partial
+
+
+class WifiTxPowerCheckTest(base_test.BaseTestClass):
+ """Class for ping-based Wifi performance tests.
+
+ This class implements WiFi ping performance tests such as range and RTT.
+ The class setups up the AP in the desired configurations, configures
+ and connects the phone to the AP, and runs For an example config file to
+ run this test class see example_connectivity_performance_ap_sta.json.
+ """
+
+ TEST_TIMEOUT = 10
+ RSSI_POLL_INTERVAL = 0.2
+ SHORT_SLEEP = 1
+ MED_SLEEP = 5
+ MAX_CONSECUTIVE_ZEROS = 5
+ DISCONNECTED_PING_RESULT = {
+ 'connected': 0,
+ 'rtt': [],
+ 'time_stamp': [],
+ 'ping_interarrivals': [],
+ 'packet_loss_percentage': 100
+ }
+
+ BRCM_SAR_MAPPING = {
+ 0: 'disable',
+ 1: 'head',
+ 2: 'grip',
+ 16: 'bt',
+ 32: 'hotspot'
+ }
+
+ BAND_TO_CHANNEL_MAP = {
+ ('2g', 1): [1, 6, 11],
+ ('5g', 1): [36, 40, 44, 48],
+ ('5g', 2): [52, 56, 60, 64],
+ ('5g', 3): range(100, 148, 4),
+ ('5g', 4): [149, 153, 157, 161],
+ ('6g', 1): ['6g{}'.format(channel) for channel in range(1, 46, 4)],
+ ('6g', 2): ['6g{}'.format(channel) for channel in range(49, 94, 4)],
+ ('6g', 3): ['6g{}'.format(channel) for channel in range(97, 114, 4)],
+ ('6g', 4): ['6g{}'.format(channel) for channel in range(117, 158, 4)],
+ ('6g', 5): ['6g{}'.format(channel) for channel in range(161, 186, 4)],
+ ('6g', 6): ['6g{}'.format(channel) for channel in range(189, 234, 4)]
+ }
+
+ 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', '6g117', '6g213'],
+ modes=['bw20', 'bw40', 'bw80', 'bw160'],
+ test_types=[
+ 'test_tx_power',
+ ],
+ country_codes=['US', 'GB', 'JP'],
+ sar_states=range(0, 13))
+
+ def setup_class(self):
+ self.dut = self.android_devices[-1]
+ req_params = [
+ 'tx_power_test_params', 'testbed_params', 'main_network',
+ 'RetailAccessPoints', 'RemoteServer'
+ ]
+ opt_params = ['OTASniffer']
+ self.unpack_userparams(req_params, opt_params)
+ self.testclass_params = self.tx_power_test_params
+ self.num_atten = self.attenuators[0].instrument.num_atten
+ self.ping_server = ssh.connection.SshConnection(
+ ssh.settings.from_config(self.RemoteServer[0]['ssh_config']))
+ self.access_point = retail_ap.create(self.RetailAccessPoints)[0]
+ if hasattr(self,
+ 'OTASniffer') and self.testbed_params['sniffer_enable']:
+ try:
+ self.sniffer = ota_sniffer.create(self.OTASniffer)[0]
+ except:
+ self.log.warning('Could not start sniffer. Disabling sniffs.')
+ self.testbed_params['sniffer_enable'] = 0
+ self.log.info('Access Point Configuration: {}'.format(
+ self.access_point.ap_settings))
+ self.log_path = os.path.join(logging.log_path, 'results')
+ os.makedirs(self.log_path, exist_ok=True)
+ self.atten_dut_chain_map = {}
+ self.testclass_results = []
+
+ # Turn WiFi ON
+ if self.testclass_params.get('airplane_mode', 1):
+ self.log.info('Turning on airplane mode.')
+ asserts.assert_true(utils.force_airplane_mode(self.dut, True),
+ 'Can not turn on airplane mode.')
+ wutils.wifi_toggle_state(self.dut, True)
+ self.dut.droid.wifiEnableVerboseLogging(1)
+ asserts.assert_equal(self.dut.droid.wifiGetVerboseLoggingLevel(), 1,
+ "Failed to enable WiFi verbose logging.")
+
+ # decode nvram
+ self.nvram_sar_data = self.read_nvram_sar_data()
+ self.csv_sar_data = self.read_sar_csv(self.testclass_params['sar_csv'])
+
+ def teardown_class(self):
+ # Turn WiFi OFF and reset AP
+ self.access_point.teardown()
+ for dev in self.android_devices:
+ wutils.wifi_toggle_state(dev, False)
+ dev.go_to_sleep()
+ self.process_testclass_results()
+
+ def setup_test(self):
+ self.retry_flag = False
+
+ def teardown_test(self):
+ self.retry_flag = False
+
+ 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.
+ """
+ self.retry_flag = True
+ for dev in self.android_devices:
+ wutils.reset_wifi(dev)
+ wutils.toggle_wifi_off_and_on(dev)
+
+ def read_sar_csv(self, sar_csv):
+ """Reads SAR powers from CSV.
+
+ This function reads SAR powers from a CSV and generate a dictionary
+ with all programmed TX powers on a per band and regulatory domain
+ basis.
+
+ Args:
+ sar_csv: path to SAR data file.
+ Returns:
+ sar_powers: dict containing all SAR data
+ """
+
+ sar_powers = {}
+ sar_csv_data = []
+ with open(sar_csv, mode='r') as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ row['Sub-band Powers'] = [
+ float(val) for key, val in row.items()
+ if 'Sub-band' in key and val != ''
+ ]
+ sar_csv_data.append(row)
+
+ for row in sar_csv_data:
+ sar_powers.setdefault(int(row['Scenario Index']), {})
+ sar_powers[int(row['Scenario Index'])].setdefault('SAR Powers', {})
+ sar_row_key = (row['Regulatory Domain'], row['Mode'], row['Band'])
+ sar_powers[int(row['Scenario Index'])]['SAR Powers'].setdefault(
+ sar_row_key, {})
+ sar_powers[int(
+ row['Scenario Index'])]['SAR Powers'][sar_row_key][int(
+ row['Chain'])] = row['Sub-band Powers']
+ return sar_powers
+
+ def read_nvram_sar_data(self):
+ """Reads SAR powers from NVRAM.
+
+ This function reads SAR powers from the NVRAM found on the DUT and
+ generates a dictionary with all programmed TX powers on a per band and
+ regulatory domain basis. NThe NVRAM file is chosen based on the build,
+ but if no NVRAM file is found matching the expected name, the default
+ NVRAM will be loaded. The choice of NVRAM is not guaranteed to be
+ correct.
+
+ Returns:
+ nvram_sar_data: dict containing all SAR data
+ """
+
+ self._read_sar_config_info()
+ try:
+ hardware_version = self.dut.adb.shell(
+ 'getprop ro.boot.hardware.revision')
+ nvram_path = '/vendor/firmware/bcmdhd.cal_{}'.format(
+ hardware_version)
+ nvram = self.dut.adb.shell('cat {}'.format(nvram_path))
+ except:
+ nvram = self.dut.adb.shell('cat /vendor/firmware/bcmdhd.cal')
+ current_context = context.get_current_context().get_full_output_path()
+ file_path = os.path.join(current_context, 'nvram_file')
+ with open(file_path, 'w') as file:
+ file.write(nvram)
+ nvram_sar_data = {}
+ for line in nvram.splitlines():
+ if 'dynsar' in line:
+ sar_config, sar_powers = self._parse_nvram_sar_line(line)
+ nvram_sar_data[sar_config] = sar_powers
+ file_path = os.path.join(current_context, 'nvram_sar_data')
+ with open(file_path, 'w') as file:
+ json.dump(wputils.serialize_dict(nvram_sar_data), file, indent=4)
+
+ return nvram_sar_data
+
+ def _read_sar_config_info(self):
+ """Function to read SAR scenario mapping,
+
+ This function reads sar_config.info file which contains the mapping
+ of SAR scenarios to NVRAM data tables.
+ """
+
+ self.sar_state_mapping = collections.OrderedDict([(-1, {
+ "google_name":
+ 'WIFI_POWER_SCENARIO_DISABLE'
+ }), (0, {
+ "google_name": 'WIFI_POWER_SCENARIO_DISABLE'
+ }), (1, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF'
+ }), (2, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON'
+ }), (3, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF'
+ }), (4, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_CELL_ON'
+ }), (5, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_BT'
+ }), (6, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT'
+ }), (7, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT_MMW'
+ }), (8, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_BT'
+ }), (9, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT'
+ }), (10, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT'
+ }), (11, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_MMW'
+ }), (12, {
+ "google_name": 'WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT_MMW'
+ })])
+ sar_config_path = '/vendor/firmware/sarconfig.info'
+ sar_config = self.dut.adb.shell(
+ 'cat {}'.format(sar_config_path)).splitlines()
+ sar_config = [line.split(',') for line in sar_config]
+ sar_config = [[int(x) for x in line] for line in sar_config]
+
+ for sar_state in sar_config:
+ self.sar_state_mapping[sar_state[0]]['brcm_index'] = (
+ self.BRCM_SAR_MAPPING[sar_state[1]], bool(sar_state[2]))
+ current_context = context.get_current_context().get_full_output_path()
+ file_path = os.path.join(current_context, 'sarconfig')
+ with open(file_path, 'w') as file:
+ json.dump(wputils.serialize_dict(self.sar_state_mapping),
+ file,
+ indent=4)
+
+ def _parse_nvram_sar_line(self, sar_line):
+ """Helper function to decode SAR NVRAM data lines.
+
+ Args:
+ sar_line: single line of text from NVRAM file containing SAR data.
+ Returns:
+ sar_config: sar config referenced in this line
+ decoded_values: tx powers configured in this line
+ """
+
+ sar_config = collections.OrderedDict()
+ list_of_countries = ['fcc', 'jp']
+ try:
+ sar_config['country'] = next(country
+ for country in list_of_countries
+ if country in sar_line)
+ 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)
+ 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)
+
+ sar_config['rsdb'] = 'rsdb' if 'rsdb' in sar_line else 'mimo'
+ sar_config['airplane_mode'] = '_2=' in sar_line
+
+ sar_powers = sar_line.split('=')[1].split(',')
+ decoded_powers = []
+ for sar_power in sar_powers:
+ decoded_powers.append([
+ (int(sar_power[2:4], 16) & int('7f', 16)) / 4,
+ (int(sar_power[4:], 16) & int('7f', 16)) / 4
+ ])
+
+ return tuple(sar_config.values()), decoded_powers
+
+ def get_sar_power_from_nvram(self, testcase_params):
+ """Function to get current expected SAR power from nvram
+
+ This functions gets the expected SAR TX power from the DUT NVRAM data.
+ The SAR power is looked up based on the current channel and regulatory
+ domain,
+
+ Args:
+ testcase_params: dict containing channel, sar state, country code
+ Returns:
+ sar_config: current expected sar config
+ sar_powers: current expected sar powers
+ """
+
+ if testcase_params['country_code'] == 'US':
+ reg_domain = 'fcc'
+ elif testcase_params['country_code'] == 'JP':
+ reg_domain = 'jp'
+ else:
+ reg_domain = 'row'
+ for band, channels in self.BAND_TO_CHANNEL_MAP.items():
+ if testcase_params['channel'] in channels:
+ current_band = band[0]
+ sub_band_idx = band[1]
+ break
+ sar_config = (reg_domain, self.sar_state_mapping[
+ testcase_params['sar_state']]['brcm_index'][0], current_band,
+ 'mimo', self.sar_state_mapping[
+ testcase_params['sar_state']]['brcm_index'][1])
+ sar_powers = self.nvram_sar_data[sar_config][sub_band_idx - 1]
+ return sar_config, sar_powers
+
+ def get_sar_power_from_csv(self, testcase_params):
+ """Function to get current expected SAR power from CSV.
+
+ This functions gets the expected SAR TX power from the DUT NVRAM data.
+ The SAR power is looked up based on the current channel and regulatory
+ domain,
+
+ Args:
+ testcase_params: dict containing channel, sar state, country code
+ Returns:
+ sar_config: current expected sar config
+ sar_powers: current expected sar powers
+ """
+
+ if testcase_params['country_code'] == 'US':
+ reg_domain = 'fcc'
+ elif testcase_params['country_code'] == 'JP':
+ reg_domain = 'jp'
+ else:
+ reg_domain = 'row'
+ for band, channels in self.BAND_TO_CHANNEL_MAP.items():
+ if testcase_params['channel'] in channels:
+ current_band = band[0]
+ sub_band_idx = band[1]
+ break
+ sar_config = (reg_domain, 'mimo', current_band)
+ sar_powers = [
+ self.csv_sar_data[testcase_params['sar_state']]['SAR Powers']
+ [sar_config][0][sub_band_idx - 1],
+ self.csv_sar_data[testcase_params['sar_state']]['SAR Powers']
+ [sar_config][1][sub_band_idx - 1]
+ ]
+ return sar_config, sar_powers
+
+ def process_wl_curpower(self, wl_curpower_file, testcase_params):
+ """Function to parse wl_curpower output.
+
+ Args:
+ wl_curpower_file: path to curpower output file.
+ testcase_params: dict containing channel, sar state, country code
+ Returns:
+ wl_curpower_dict: dict formatted version of curpower data.
+ """
+
+ with open(wl_curpower_file, 'r') as file:
+ wl_curpower_out = file.read()
+
+ channel_regex = re.compile(r'Current Channel:\s+(?P<channel>[0-9]+)')
+ bandwidth_regex = re.compile(
+ r'Channel Width:\s+(?P<bandwidth>\S+)MHz\n')
+
+ channel = int(
+ re.search(channel_regex, wl_curpower_out).group('channel'))
+ bandwidth = int(
+ re.search(bandwidth_regex, wl_curpower_out).group('bandwidth'))
+
+ regulatory_limits = self.generate_regulatory_table(
+ wl_curpower_out, channel, bandwidth)
+ board_limits = self.generate_board_limit_table(wl_curpower_out,
+ channel, bandwidth)
+ wl_curpower_dict = {
+ 'channel': channel,
+ 'bandwidth': bandwidth,
+ 'country': testcase_params['country_code'],
+ 'regulatory_limits': regulatory_limits,
+ 'board_limits': board_limits
+ }
+ return wl_curpower_dict
+
+ def generate_regulatory_table(self, wl_curpower_out, channel, bw):
+ """"Helper function to generate regulatory limit table from curpower.
+
+ Args:
+ wl_curpower_out: curpower output
+ channel: current channel
+ bw: current bandwidth
+ Returns:
+ regulatory_table: dict with regulatory limits for current config
+ """
+
+ regulatory_group_map = {
+ 'DSSS':
+ [('CCK', rate, 1)
+ for rate in ['{}Mbps'.format(mbps) for mbps in [1, 2, 5.5, 11]]],
+ 'OFDM_CDD1': [('LEGACY', rate, 1) for rate in [
+ '{}Mbps'.format(mbps)
+ for mbps in [6, 9, 12, 18, 24, 36, 48, 54]
+ ]],
+ 'MCS0_7_CDD1':
+ [(mode, rate, 1)
+ for (mode,
+ rate) in itertools.product(['HT' + str(bw), 'VHT' +
+ str(bw)], range(0, 8))],
+ 'VHT8_9SS1_CDD1': [('VHT' + str(bw), 8, 1),
+ ('VHT' + str(bw), 9, 1)],
+ 'VHT10_11SS1_CDD1': [('VHT' + str(bw), 10, 1),
+ ('VHT' + str(bw), 11, 1)],
+ 'MCS8_15':
+ [(mode, rate - 8 * ('VHT' in mode), 2)
+ for (mode,
+ rate) in itertools.product(['HT' + str(bw), 'VHT' +
+ str(bw)], range(8, 16))],
+ 'VHT8_9SS2': [('VHT' + str(bw), 8, 2), ('VHT' + str(bw), 9, 2)],
+ 'VHT10_11SS2': [('VHT' + str(bw), 10, 2),
+ ('VHT' + str(bw), 11, 2)],
+ 'HE_MCS0-11_CDD1': [('HE' + str(bw), rate, 1)
+ for rate in range(0, 12)],
+ 'HE_MCS0_11SS2': [('HE' + str(bw), rate, 2)
+ for rate in range(0, 12)],
+ }
+ tx_power_regex = re.compile(
+ '(?P<mcs>\S+)\s+(?P<chain>[2])\s+(?P<power_1>[0-9.-]+)\s*(?P<power_2>[0-9.-]*)\s*(?P<power_3>[0-9.-]*)\s*(?P<power_4>[0-9.-]*)'
+ )
+
+ regulatory_section_regex = re.compile(
+ r'Regulatory Limits:(?P<regulatory_limits>[\S\s]+)Board Limits:')
+ regulatory_list = re.search(regulatory_section_regex,
+ wl_curpower_out).group('regulatory_limits')
+ regulatory_list = re.findall(tx_power_regex, regulatory_list)
+ regulatory_dict = {entry[0]: entry[2:] for entry in regulatory_list}
+
+ bw_index = int(math.log(bw / 10, 2)) - 1
+ regulatory_table = collections.OrderedDict()
+ for regulatory_group, rates in regulatory_group_map.items():
+ for rate in rates:
+ reg_power = regulatory_dict.get(regulatory_group,
+ ['0', '0', '0', '0'])[bw_index]
+ regulatory_table[rate] = float(
+ reg_power) if reg_power != '-' else 0
+ return regulatory_table
+
+ def generate_board_limit_table(self, wl_curpower_out, channel, bw):
+ """"Helper function to generate board limit table from curpower.
+
+ Args:
+ wl_curpower_out: curpower output
+ channel: current channel
+ bw: current bandwidth
+ Returns:
+ board_limit_table: dict with board limits for current config
+ """
+
+ tx_power_regex = re.compile(
+ '(?P<mcs>\S+)\s+(?P<chain>[2])\s+(?P<power_1>[0-9.-]+)\s*(?P<power_2>[0-9.-]*)\s*(?P<power_3>[0-9.-]*)\s*(?P<power_4>[0-9.-]*)'
+ )
+
+ board_section_regex = re.compile(
+ r'Board Limits:(?P<board_limits>[\S\s]+)Power Targets:')
+ board_limits_list = re.search(board_section_regex,
+ wl_curpower_out).group('board_limits')
+ board_limits_list = re.findall(tx_power_regex, board_limits_list)
+ board_limits_dict = {
+ entry[0]: entry[2:]
+ for entry in board_limits_list
+ }
+
+ mcs_regex_list = [[
+ re.compile('DSSS'),
+ [('CCK', rate, 1)
+ for rate in ['{}Mbps'.format(mbps) for mbps in [1, 2, 5.5, 11]]]
+ ], [re.compile('OFDM(?P<mcs>[0-9]+)_CDD1'), [('LEGACY', '{}Mbps', 1)]],
+ [
+ re.compile('MCS(?P<mcs>[0-7])_CDD1'),
+ [('HT{}'.format(bw), '{}', 1),
+ ('VHT{}'.format(bw), '{}', 1)]
+ ],
+ [
+ re.compile('VHT(?P<mcs>[8-9])SS1_CDD1'),
+ [('VHT{}'.format(bw), '{}', 1)]
+ ],
+ [
+ re.compile('VHT10_11SS1_CDD1'),
+ [('VHT{}'.format(bw), '10', 1),
+ ('VHT{}'.format(bw), '11', 1)]
+ ],
+ [
+ re.compile('MCS(?P<mcs>[0-9]{2})'),
+ [('HT{}'.format(bw), '{}', 2)]
+ ],
+ [
+ re.compile('VHT(?P<mcs>[0-9])SS2'),
+ [('VHT{}'.format(bw), '{}', 2)]
+ ],
+ [
+ re.compile('VHT10_11SS2'),
+ [('VHT{}'.format(bw), '10', 2),
+ ('VHT{}'.format(bw), '11', 2)]
+ ],
+ [
+ re.compile('HE_MCS(?P<mcs>[0-9]+)_CDD1'),
+ [('HE{}'.format(bw), '{}', 1)]
+ ],
+ [
+ re.compile('HE_MCS(?P<mcs>[0-9]+)SS2'),
+ [('HE{}'.format(bw), '{}', 2)]
+ ]]
+
+ bw_index = int(math.log(bw / 10, 2)) - 1
+ board_limit_table = collections.OrderedDict()
+ for mcs, board_limit in board_limits_dict.items():
+ for mcs_regex_tuple in mcs_regex_list:
+ mcs_match = re.match(mcs_regex_tuple[0], mcs)
+ if mcs_match:
+ for possible_mcs in mcs_regex_tuple[1]:
+ try:
+ curr_mcs = (possible_mcs[0],
+ possible_mcs[1].format(
+ mcs_match.group('mcs')),
+ possible_mcs[2])
+ except:
+ curr_mcs = (possible_mcs[0], possible_mcs[1],
+ possible_mcs[2])
+ board_limit_table[curr_mcs] = float(
+ board_limit[bw_index]
+ ) if board_limit[bw_index] != '-' else 0
+ break
+ return board_limit_table
+
+ def pass_fail_check(self, result):
+ """Function to evaluate if current TX powqe matches CSV/NVRAM settings.
+
+ This function assesses whether the current TX power reported by the
+ DUT matches the powers programmed in NVRAM and CSV after applying the
+ correct TX power backoff used to account for CLPC errors.
+ """
+
+ if isinstance(result['testcase_params']['channel'],
+ str) and '6g' in result['testcase_params']['channel']:
+ mode = 'HE' + str(result['testcase_params']['bandwidth'])
+ else:
+ mode = 'VHT' + 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'])
+ csv_config, csv_powers = self.get_sar_power_from_csv(
+ result['testcase_params'])
+ self.log.info("SAR state: {} ({})".format(
+ result['testcase_params']['sar_state'],
+ self.sar_state_mapping[result['testcase_params']['sar_state']],
+ ))
+ self.log.info("Country Code: {}".format(
+ 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
+ ]
+ 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'])
+ max_error = max([
+ abs(expected_power[idx] - result['tx_powers'][idx])
+ for idx in [0, 1]
+ ])
+ if max_error > 1:
+ asserts.fail(power_str)
+ else:
+ asserts.explicit_pass(power_str)
+
+ def process_testclass_results(self):
+ pass
+
+ def run_tx_power_test(self, testcase_params):
+ """Main function to test tx power.
+
+ The function sets up the AP & DUT in the correct channel and mode
+ configuration, starts ping traffic and queries the current TX power.
+
+ Args:
+ testcase_params: dict containing all test parameters
+ Returns:
+ test_result: dict containing ping results and other meta data
+ """
+ # Prepare results dict
+ llstats_obj = wputils.LinkLayerStats(
+ self.dut, self.testclass_params.get('llstats_enabled', True))
+ test_result = collections.OrderedDict()
+ test_result['testcase_params'] = testcase_params.copy()
+ test_result['test_name'] = self.current_test_name
+ test_result['ap_config'] = self.access_point.ap_settings.copy()
+ test_result['attenuation'] = testcase_params['atten_range']
+ test_result['fixed_attenuation'] = self.testbed_params[
+ 'fixed_attenuation'][str(testcase_params['channel'])]
+ test_result['rssi_results'] = []
+ test_result['ping_results'] = []
+ test_result['llstats'] = []
+ # Setup sniffer
+ if self.testbed_params['sniffer_enable']:
+ self.sniffer.start_capture(
+ testcase_params['test_network'],
+ chan=testcase_params['channel'],
+ bw=testcase_params['bandwidth'],
+ duration=testcase_params['ping_duration'] *
+ len(testcase_params['atten_range']) + self.TEST_TIMEOUT)
+ # Run ping and sweep attenuation as needed
+ self.log.info('Starting ping.')
+ thread_future = wputils.get_ping_stats_nb(self.ping_server,
+ self.dut_ip, 10, 0.02, 64)
+
+ for atten in testcase_params['atten_range']:
+ for attenuator in self.attenuators:
+ attenuator.set_atten(atten, strict=False, retry=True)
+ # Set mcs
+ if isinstance(testcase_params['channel'],
+ int) and testcase_params['channel'] < 13:
+ self.dut.adb.shell('wl 2g_rate -v 0x2 -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(
+ 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
+ self.log.info('Current Country: {}'.format(
+ self.dut.adb.shell('wl country')))
+ # Dump last est power multiple times
+ chain_0_power = []
+ chain_1_power = []
+ for idx in range(30):
+ 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
+ ]
+ self.log.info(
+ 'Current Tx Powers = {}'.format(per_chain_powers))
+ if per_chain_powers[0] > 0:
+ chain_0_power.append(per_chain_powers[0])
+ if per_chain_powers[1] > 0:
+ chain_1_power.append(per_chain_powers[1])
+ time.sleep(0.25)
+ # Check if empty
+ if len(chain_0_power) == 0 or len(chain_1_power) == 0:
+ test_result['tx_powers'] = [0, 0]
+ tx_power_frequency = [100, 100]
+ else:
+ test_result['tx_powers'] = [
+ scipy.stats.mode(chain_0_power).mode[0],
+ scipy.stats.mode(chain_1_power).mode[0]
+ ]
+ tx_power_frequency = [
+ 100 * scipy.stats.mode(chain_0_power).count[0] /
+ len(chain_0_power),
+ 100 * scipy.stats.mode(chain_1_power).count[0] /
+ len(chain_0_power)
+ ]
+ self.log.info(
+ 'Filtered Tx Powers = {}. Frequency = [{:.0f}%, {:.0f}%]'.
+ format(test_result['tx_powers'], tx_power_frequency[0],
+ tx_power_frequency[1]))
+ llstats_obj.update_stats()
+ curr_llstats = llstats_obj.llstats_incremental.copy()
+ test_result['llstats'].append(curr_llstats)
+ # DUMP wl curpower one
+ try:
+ wl_curpower = self.dut.adb.shell('wl curpower')
+ except:
+ time.sleep(0.25)
+ wl_curpower = self.dut.adb.shell('wl curpower',
+ ignore_status=True)
+ current_context = context.get_current_context(
+ ).get_full_output_path()
+ wl_curpower_path = os.path.join(current_context,
+ 'wl_curpower_output')
+ with open(wl_curpower_path, 'w') as file:
+ file.write(wl_curpower)
+ wl_curpower_dict = self.process_wl_curpower(
+ wl_curpower_path, testcase_params)
+ wl_curpower_path = os.path.join(current_context,
+ 'wl_curpower_dict')
+ with open(wl_curpower_path, 'w') as file:
+ json.dump(wputils.serialize_dict(wl_curpower_dict),
+ file,
+ indent=4)
+ test_result['wl_curpower'] = wl_curpower_dict
+ thread_future.result()
+ if self.testbed_params['sniffer_enable']:
+ self.sniffer.stop_capture()
+ return test_result
+
+ def setup_ap(self, testcase_params):
+ """Sets up the access point in the configuration required by the test.
+
+ Args:
+ testcase_params: dict containing AP and other test params
+ """
+ band = self.access_point.band_lookup_by_channel(
+ testcase_params['channel'])
+ if '6G' in band:
+ frequency = wutils.WifiEnums.channel_6G_to_freq[int(
+ testcase_params['channel'].strip('6g'))]
+ else:
+ if testcase_params['channel'] < 13:
+ frequency = wutils.WifiEnums.channel_2G_to_freq[
+ testcase_params['channel']]
+ else:
+ frequency = wutils.WifiEnums.channel_5G_to_freq[
+ testcase_params['channel']]
+ if frequency in wutils.WifiEnums.DFS_5G_FREQUENCIES:
+ 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'])
+ if 'low' in testcase_params['ap_power']:
+ self.log.info('Setting low AP power.')
+ self.access_point.set_power(
+ band, self.testclass_params['low_ap_tx_power'])
+ self.log.info('Access Point Configuration: {}'.format(
+ self.access_point.ap_settings))
+
+ def setup_dut(self, testcase_params):
+ """Sets up the DUT in the configuration required by the test.
+
+ Args:
+ testcase_params: dict containing AP and other test params
+ """
+ # Turn screen off to preserve battery
+ if self.testbed_params.get('screen_on',
+ False) or self.testclass_params.get(
+ 'screen_on', False):
+ self.dut.droid.wakeLockAcquireDim()
+ else:
+ self.dut.go_to_sleep()
+ if wputils.validate_network(self.dut,
+ testcase_params['test_network']['SSID']):
+ current_country = self.dut.adb.shell('wl country')
+ self.log.info('Current country code: {}'.format(current_country))
+ if testcase_params['country_code'] in current_country:
+ self.log.info('Already connected to desired network')
+ self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses(
+ 'wlan0')[0]
+ return
+ testcase_params['test_network']['channel'] = testcase_params['channel']
+ wutils.wifi_toggle_state(self.dut, False)
+ wutils.set_wifi_country_code(self.dut, testcase_params['country_code'])
+ wutils.wifi_toggle_state(self.dut, True)
+ wutils.reset_wifi(self.dut)
+ if self.testbed_params.get('txbf_off', False):
+ wputils.disable_beamforming(self.dut)
+ wutils.set_wifi_country_code(self.dut, testcase_params['country_code'])
+ wutils.wifi_connect(self.dut,
+ testcase_params['test_network'],
+ num_of_tries=1,
+ check_connectivity=True)
+ self.dut_ip = self.dut.droid.connectivityGetIPv4Addresses('wlan0')[0]
+
+ def setup_tx_power_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 0 dB
+ for attenuator in self.attenuators:
+ attenuator.set_atten(0, strict=False, retry=True)
+ # Reset, configure, and connect DUT
+ self.setup_dut(testcase_params)
+
+ def check_skip_conditions(self, testcase_params):
+ """Checks if test should be skipped."""
+ # Check battery level before test
+ if not wputils.health_check(self.dut, 10):
+ asserts.skip('DUT battery level too low.')
+ if testcase_params[
+ 'channel'] in wputils.CHANNELS_6GHz and not self.dut.droid.is6GhzBandSupported(
+ ):
+ asserts.skip('DUT does not support 6 GHz band.')
+ if not self.access_point.band_lookup_by_channel(
+ testcase_params['channel']):
+ asserts.skip('AP does not support requested channel.')
+
+ def compile_test_params(self, testcase_params):
+ """Function to compile all testcase parameters."""
+
+ self.check_skip_conditions(testcase_params)
+
+ band = self.access_point.band_lookup_by_channel(
+ testcase_params['channel'])
+ testcase_params['test_network'] = self.main_network[band]
+ testcase_params['attenuated_chain'] = -1
+ testcase_params.update(
+ ping_interval=self.testclass_params['ping_interval'],
+ ping_duration=self.testclass_params['ping_duration'],
+ ping_size=self.testclass_params['ping_size'],
+ )
+
+ testcase_params['atten_range'] = [0]
+ return testcase_params
+
+ def _test_ping(self, testcase_params):
+ """ Function that gets called for each range test case
+
+ The function gets called in each range test case. It customizes the
+ range test based on the test name of the test that called it
+
+ Args:
+ testcase_params: dict containing preliminary set of parameters
+ """
+ # Compile test parameters from config and test name
+ testcase_params = self.compile_test_params(testcase_params)
+ # Run ping test
+ self.setup_tx_power_test(testcase_params)
+ result = self.run_tx_power_test(testcase_params)
+ self.pass_fail_check(result)
+
+ def generate_test_cases(self, ap_power, channels, modes, test_types,
+ country_codes, sar_states):
+ """Function that auto-generates test cases for a test class."""
+ test_cases = []
+ allowed_configs = {
+ 20: [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 52, 64, 100,
+ 116, 132, 140, 149, 153, 157, 161
+ ],
+ 40: [36, 44, 100, 149, 157],
+ 80: [36, 100, 149],
+ 160: [36, '6g37', '6g117', '6g213']
+ }
+
+ for channel, mode, test_type, country_code, sar_state in itertools.product(
+ channels, modes, test_types, country_codes, sar_states):
+ bandwidth = int(''.join([x for x in mode if x.isdigit()]))
+ if channel not in allowed_configs[bandwidth]:
+ continue
+ testcase_name = '{}_ch{}_{}_{}_sar_{}'.format(
+ test_type, channel, mode, country_code, sar_state)
+ testcase_params = collections.OrderedDict(
+ test_type=test_type,
+ ap_power=ap_power,
+ channel=channel,
+ mode=mode,
+ bandwidth=bandwidth,
+ country_code=country_code,
+ sar_state=sar_state)
+ setattr(self, testcase_name,
+ partial(self._test_ping, testcase_params))
+ test_cases.append(testcase_name)
+ return test_cases
diff --git a/acts_tests/tests/google/wifi/aware/functional/ProtocolsMultiCountryTest.py b/acts_tests/tests/google/wifi/aware/functional/ProtocolsMultiCountryTest.py
new file mode 100644
index 0000000..f23ecb7
--- /dev/null
+++ b/acts_tests/tests/google/wifi/aware/functional/ProtocolsMultiCountryTest.py
@@ -0,0 +1,231 @@
+#!/usr/bin/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 acts.test_utils.wifi.wifi_test_utils as wutils
+
+import time
+import random
+import re
+import logging
+import acts.controllers.packet_capture as packet_capture
+import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
+
+from acts import asserts
+from acts.test_decorators import test_tracker_info
+from acts_contrib.test_utils.net import nsd_const as nconsts
+from acts_contrib.test_utils.wifi.aware import aware_const as aconsts
+from acts_contrib.test_utils.wifi.aware import aware_test_utils as autils
+from acts_contrib.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+from acts.controllers.ap_lib.hostapd_constants import CHANNEL_MAP
+
+WifiEnums = wutils.WifiEnums
+
+class ProtocolsMultiCountryTest(AwareBaseTest):
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+ self.basetest_name = (
+ "ping6_ib_unsolicited_passive_multicountry",
+ "ping6_ib_solicited_active_multicountry",
+ )
+
+ self.generate_tests()
+
+ def generate_testcase(self, basetest_name, country):
+ """Generates a single test case from the given data.
+
+ Args:
+ basetest_name: The name of the base test case.
+ country: The information about the country code under test.
+ """
+ base_test = getattr(self, basetest_name)
+ test_tracker_uuid = ""
+
+ testcase_name = 'test_%s_%s' % (basetest_name, country)
+ test_case = test_tracker_info(uuid=test_tracker_uuid)(
+ lambda: base_test(country))
+ setattr(self, testcase_name, test_case)
+ self.tests.append(testcase_name)
+
+ def generate_tests(self):
+ for country in self.user_params['wifi_country_code']:
+ for basetest_name in self.basetest_name:
+ self.generate_testcase(basetest_name, country)
+
+ def setup_class(self):
+ super().setup_class()
+ for ad in self.android_devices:
+ ad.droid.wakeLockAcquireBright()
+ ad.droid.wakeUpNow()
+ wutils.wifi_test_device_init(ad)
+
+ if hasattr(self, 'packet_capture'):
+ self.packet_capture = self.packet_capture[0]
+ self.channel_list_2g = WifiEnums.ALL_2G_FREQUENCIES
+ self.channel_list_5g = WifiEnums.ALL_5G_FREQUENCIES
+
+ def setup_test(self):
+ super(ProtocolsMultiCountryTest, self).setup_test()
+ for ad in self.android_devices:
+ ad.ed.clear_all_events()
+
+ def test_time(self,begin_time):
+ super(ProtocolsMultiCountryTest, self).setup_test()
+ for ad in self.android_devices:
+ ad.cat_adb_log(begin_time)
+
+ def teardown_test(self):
+ super(ProtocolsMultiCountryTest, self).teardown_test()
+ for ad in self.android_devices:
+ ad.adb.shell("cmd wifiaware reset")
+
+
+ """Set of tests for Wi-Fi Aware data-paths: validating protocols running on
+ top of a data-path"""
+
+ SERVICE_NAME = "GoogleTestServiceXY"
+
+ def run_ping6(self, dut, peer_ipv6):
+ """Run a ping6 over the specified device/link
+ Args:
+ dut: Device on which to execute ping6
+ peer_ipv6: Scoped IPv6 address of the peer to ping
+ """
+ cmd = "ping6 -c 3 -W 5 %s" % peer_ipv6
+ results = dut.adb.shell(cmd)
+ self.log.info("cmd='%s' -> '%s'", cmd, results)
+ if results == "":
+ asserts.fail("ping6 empty results - seems like a failure")
+
+ def get_ndp_freq(self, dut):
+ """ get aware interface status"""
+ get_nda0 = "timeout 3 logcat | grep getNdpConfirm | grep Channel"
+ out_nda01 = dut.adb.shell(get_nda0)
+ out_nda0 = re.findall("Channel = (\d+)", out_nda01)
+ return out_nda0
+
+
+ def conf_packet_capture(self, band, channel):
+ """Configure packet capture on necessary channels."""
+ freq_to_chan = wutils.WifiEnums.freq_to_channel[int(channel)]
+ logging.info("Capturing packets from "
+ "frequency:{}, Channel:{}".format(channel, freq_to_chan))
+ result = self.packet_capture.configure_monitor_mode(band, freq_to_chan)
+ if not result:
+ logging.error("Failed to configure channel "
+ "for {} band".format(band))
+ self.pcap_procs = wutils.start_pcap(
+ self.packet_capture, band, self.test_name)
+ time.sleep(5)
+
+ ########################################################################
+
+ @test_tracker_info(uuid="3b09e666-c526-4879-8180-77d9a55a2833")
+ def ping6_ib_unsolicited_passive_multicountry(self, country):
+ """Validate that ping6 works correctly on an NDP created using Aware
+ discovery with UNSOLICITED/PASSIVE sessions."""
+ p_dut = self.android_devices[0]
+ s_dut = self.android_devices[1]
+ wutils.set_wifi_country_code(p_dut, country)
+ wutils.set_wifi_country_code(s_dut, country)
+ #p_dut.adb.shell("timeout 12 logcat -c")
+ # create NDP
+ (p_req_key, s_req_key, p_aware_if, s_aware_if, p_ipv6,
+ s_ipv6) = autils.create_ib_ndp(
+ p_dut,
+ s_dut,
+ p_config=autils.create_discovery_config(
+ self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED),
+ s_config=autils.create_discovery_config(
+ self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_PASSIVE),
+ device_startup_offset=self.device_startup_offset)
+ self.log.info("Interface names: P=%s, S=%s", p_aware_if, s_aware_if)
+ self.log.info("Interface addresses (IPv6): P=%s, S=%s", p_ipv6, s_ipv6)
+ ndpfreg =int(self.get_ndp_freq(p_dut)[-1])
+ ndp_channel = str(CHANNEL_MAP[ndpfreg])
+ n = int(ndp_channel)
+ if n in range(len(self.channel_list_2g)):
+ ndp_band = '2g'
+ else:
+ ndp_band = '5g'
+ p_dut.log.info('ndp frequency : {}'.format(ndpfreg))
+ p_dut.log.info('ndp channel : {}'.format(ndp_channel))
+ p_dut.log.info('ndp band : {}'.format(ndp_band))
+
+ # start-snifferlog
+ if hasattr(self, 'packet_capture'):
+ self.conf_packet_capture(ndp_band, ndpfreg)
+
+ # run ping6
+ self.run_ping6(p_dut, s_ipv6)
+ self.run_ping6(s_dut, p_ipv6)
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ # stop-snifferlog
+ if hasattr(self, 'packet_capture'):
+ wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
+ time.sleep(10)
+
+ @test_tracker_info(uuid="6b54951f-bf0b-4d26-91d6-c9b3b8452873")
+ def ping6_ib_solicited_active_multicountry(self, country):
+ """Validate that ping6 works correctly on an NDP created using Aware
+ discovery with SOLICITED/ACTIVE sessions."""
+ p_dut = self.android_devices[0]
+ s_dut = self.android_devices[1]
+ wutils.set_wifi_country_code(p_dut, country)
+ wutils.set_wifi_country_code(s_dut, country)
+
+ # create NDP
+ (p_req_key, s_req_key, p_aware_if, s_aware_if, p_ipv6,
+ s_ipv6) = autils.create_ib_ndp(
+ p_dut,
+ s_dut,
+ p_config=autils.create_discovery_config(
+ self.SERVICE_NAME, aconsts.PUBLISH_TYPE_SOLICITED),
+ s_config=autils.create_discovery_config(
+ self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_ACTIVE),
+ device_startup_offset=self.device_startup_offset)
+ self.log.info("Interface names: P=%s, S=%s", p_aware_if, s_aware_if)
+ self.log.info("Interface addresses (IPv6): P=%s, S=%s", p_ipv6, s_ipv6)
+ ndpfreg =int(self.get_ndp_freq(p_dut)[-1])
+ ndp_channel = str(CHANNEL_MAP[ndpfreg])
+ n = int(ndp_channel)
+ if n in range(len(self.channel_list_2g)):
+ ndp_band = '2g'
+ else:
+ ndp_band = '5g'
+ p_dut.log.info('ndp frequency : {}'.format(ndpfreg))
+ p_dut.log.info('ndp channel : {}'.format(ndp_channel))
+ p_dut.log.info('ndp band : {}'.format(ndp_band))
+
+ # start-snifferlog
+ if hasattr(self, 'packet_capture'):
+ self.conf_packet_capture(ndp_band, ndpfreg)
+
+ # run ping6
+ self.run_ping6(p_dut, s_ipv6)
+ self.run_ping6(s_dut, p_ipv6)
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ # stop-snifferlog
+ if hasattr(self, 'packet_capture'):
+ wutils.stop_pcap(self.packet_capture, self.pcap_procs, False)
+ time.sleep(10)
diff --git a/acts_tests/tests/google/wifi/aware/performance/WifiAwareRvrTest.py b/acts_tests/tests/google/wifi/aware/performance/WifiAwareRvrTest.py
index 2e18bc7..209b081 100644
--- a/acts_tests/tests/google/wifi/aware/performance/WifiAwareRvrTest.py
+++ b/acts_tests/tests/google/wifi/aware/performance/WifiAwareRvrTest.py
@@ -26,6 +26,7 @@
from acts.controllers import iperf_client as ipc
from acts.controllers.adb_lib.error import AdbCommandError
from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
+from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.wifi import ota_sniffer
from acts_contrib.test_utils.wifi import wifi_retail_ap as retail_ap
from acts_contrib.test_utils.wifi import wifi_test_utils as wutils
@@ -119,6 +120,8 @@
wutils.wifi_toggle_state(ad, True)
def teardown_class(self):
+ for ap in self.access_points:
+ ap.teardown()
# Turn WiFi OFF
for dev in self.android_devices:
wutils.wifi_toggle_state(dev, False)
@@ -142,6 +145,12 @@
wutils.reset_wifi(ad)
wputils.stop_wifi_logging(ad)
+ def on_exception(self, test_name, begin_time):
+ for ad in self.android_devices:
+ ad.take_bug_report(test_name, begin_time)
+ ad.cat_adb_log(test_name, begin_time)
+ wutils.get_ssrdumps(ad)
+
def compute_test_metrics(self, rvr_result):
#Set test metrics
rvr_result['metrics'] = {}
@@ -271,9 +280,13 @@
ndp_config = self.android_devices[0].adb.shell(
'cmd wifiaware native_cb get_channel_info')
ndp_config = json.loads(ndp_config)
- ndp_config = ndp_config[list(ndp_config.keys())[0]][0]
- testcase_params['channel'] = wutils.WifiEnums.freq_to_channel[
- ndp_config['channelFreq']]
+ ndp_config = ndp_config[list(ndp_config.keys())[0]]
+ if ndp_config:
+ testcase_params['channel'] = wutils.WifiEnums.freq_to_channel[
+ ndp_config[0]['channelFreq']]
+ else:
+ self.log.warning('Unknown NDP channel. Setting sniffer to Ch149')
+ testcase_params['channel'] = 149
if testcase_params['channel'] < 13:
testcase_params['mode'] = 'VHT20'
else:
@@ -423,8 +436,15 @@
traffic_type=traffic_type,
traffic_direction=traffic_direction,
concurrency_state=concurrency_state)
- setattr(self, test_name, partial(self._test_aware_rvr,
- test_params))
+ test_class = self.__class__.__name__
+ if "uuid_list" in self.user_params:
+ test_tracker_uuid = self.user_params["uuid_list"][
+ test_class][test_name]
+ test_case = test_tracker_info(uuid=test_tracker_uuid)(
+ lambda: self._test_aware_rvr(test_params))
+ else:
+ test_case = partial(self._test_aware_rvr,test_params)
+ setattr(self, test_name, test_case)
test_cases.append(test_name)
return test_cases
diff --git a/acts_tests/tests/google/wifi/p2p/performance/WifiP2pRvrTest.py b/acts_tests/tests/google/wifi/p2p/performance/WifiP2pRvrTest.py
index 50c9c0e..4ea5c14 100644
--- a/acts_tests/tests/google/wifi/p2p/performance/WifiP2pRvrTest.py
+++ b/acts_tests/tests/google/wifi/p2p/performance/WifiP2pRvrTest.py
@@ -57,7 +57,9 @@
common to all tests in this class.
"""
req_params = ['p2p_rvr_test_params', 'testbed_params']
- opt_params = ['RetailAccessPoints', 'ap_networks', 'OTASniffer', 'uuid_list']
+ opt_params = [
+ 'RetailAccessPoints', 'ap_networks', 'OTASniffer', 'uuid_list'
+ ]
self.unpack_userparams(req_params, opt_params)
if hasattr(self, 'RetailAccessPoints'):
self.access_points = retail_ap.create(self.RetailAccessPoints)
@@ -123,6 +125,8 @@
ad.droid.wifiP2pSetDeviceName(ad.name)
def teardown_class(self):
+ for ap in self.access_points:
+ ap.teardown()
# Turn WiFi OFF
for ad in self.android_devices:
ad.droid.wifiP2pClose()
@@ -159,6 +163,12 @@
ad.droid.goToSleepNow()
wputils.stop_wifi_logging(ad)
+ def on_exception(self, test_name, begin_time):
+ for ad in self.android_devices:
+ ad.take_bug_report(test_name, begin_time)
+ ad.cat_adb_log(test_name, begin_time)
+ wutils.get_ssrdumps(ad)
+
def compute_test_metrics(self, rvr_result):
#Set test metrics
rvr_result['metrics'] = {}
@@ -283,9 +293,11 @@
False,
wpsSetup=wp2putils.WifiP2PEnums.WpsInfo.WIFI_WPS_INFO_PBC)
if wp2putils.is_go(self.android_devices[0]):
+ self.log.info("DUT 1 is GO.")
self.go_dut = self.android_devices[0]
self.gc_dut = self.android_devices[1]
elif wp2putils.is_go(self.android_devices[1]):
+ self.log.info("DUT 2 is GO.")
self.go_dut = self.android_devices[1]
self.gc_dut = self.android_devices[0]
except Exception as e:
@@ -485,9 +497,12 @@
traffic_type=traffic_type,
traffic_direction=traffic_direction,
concurrency_state=concurrency_state)
- test_class=self.__class__.__name__
- if hasattr(self, "uuid_list") and test_name in self.uuid_list[test_class]:
- test_case = test_tracker_info(uuid=self.uuid_list[test_class][test_name])(partial(self._test_p2p_rvr, test_params))
+ test_class = self.__class__.__name__
+ if "uuid_list" in self.user_params:
+ test_tracker_uuid = self.user_params["uuid_list"][
+ test_class][test_name]
+ test_case = test_tracker_info(uuid=test_tracker_uuid)(
+ lambda: self._test_p2p_rvr(test_params))
else:
test_case = partial(self._test_p2p_rvr, test_params)
setattr(self, test_name, test_case)
diff --git a/acts_tests/tests/google/wifi/rtt/config/wifi_rtt.json b/acts_tests/tests/google/wifi/rtt/config/wifi_rtt.json
index 1870fe9..46adc5a 100644
--- a/acts_tests/tests/google/wifi/rtt/config/wifi_rtt.json
+++ b/acts_tests/tests/google/wifi/rtt/config/wifi_rtt.json
@@ -17,5 +17,6 @@
"rtt_reference_distance_mm": 100,
"stress_test_min_iteration_count": 100,
"stress_test_target_run_time_sec" : 30,
- "dbs_supported_models" : []
+ "dbs_supported_models" : [],
+ "ranging_role_concurrency_flexible_models" : ["<models which support ranging role change with active ranging session>"]
}
diff --git a/acts_tests/tests/google/wifi/rtt/functional/AwareDiscoveryWithRangingTest.py b/acts_tests/tests/google/wifi/rtt/functional/AwareDiscoveryWithRangingTest.py
index 5f3f91b..5092b85 100644
--- a/acts_tests/tests/google/wifi/rtt/functional/AwareDiscoveryWithRangingTest.py
+++ b/acts_tests/tests/google/wifi/rtt/functional/AwareDiscoveryWithRangingTest.py
@@ -1688,7 +1688,7 @@
dd_s_id = dut2.droid.wifiAwareSubscribe(
dut2_id,
autils.create_discovery_config(
- "AA", aconsts.SUBSCRIBE_TYPE_ACTIVE), True)
+ "DD", aconsts.SUBSCRIBE_TYPE_ACTIVE), True)
autils.wait_for_event(
dut2,
autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED,
@@ -1745,7 +1745,16 @@
dut1,
autils.decorate_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED,
ee_s_id))
- if self.RANGING_INITIATOR_RESPONDER_CONCURRENCY_LIMITATION:
+ # When device has ranging role concurrency limitation, device could not be initiator
+ # and responder at the same time. There are two supported schemas:
+ # 1. Concurrency fixed mode: the role of the device depends on first Publish/Subscribe,
+ # will keep the same role until the service is terminated
+ # 2. Concurrency flexible mode: the role of the device changes with the active ranging
+ # session, when a publish/subscribe session is active but the ranging session for this
+ # service is terminated, will change the role based on the next publish/subscribe service.
+ if self.RANGING_INITIATOR_RESPONDER_CONCURRENCY_LIMITATION and \
+ (not hasattr(self, "ranging_role_concurrency_flexible_models") or
+ dut2.model not in self.ranging_role_concurrency_flexible_models):
asserts.assert_false(
aconsts.SESSION_CB_KEY_DISTANCE_MM in event["data"],
"Discovery with ranging for EE NOT expected!")
@@ -1925,4 +1934,4 @@
"Way too many discovery events without ranging!")
asserts.explicit_pass(
- "Discovery/Direct RTT Concurrency Pass", extras={"data": stats})
+ "Discovery/Direct RTT Concurrency Pass", extras={"data": stats})
\ No newline at end of file
diff --git a/acts_tests/tests/google/wifi/wifi6e/WifiApConcurrency6eTest.py b/acts_tests/tests/google/wifi/wifi6e/WifiApConcurrency6eTest.py
new file mode 100644
index 0000000..304c5ac
--- /dev/null
+++ b/acts_tests/tests/google/wifi/wifi6e/WifiApConcurrency6eTest.py
@@ -0,0 +1,89 @@
+#
+# 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 time
+from acts import asserts
+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
+
+WifiEnums = wutils.WifiEnums
+BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS = 5
+
+
+class WifiApConcurrency6eTest(WifiBaseTest):
+ """Tests for network selector 6e tests.
+
+ Test Bed Requirement:
+ 1 Android devices, 2 Asus AXE11000 Access Point.
+ """
+
+ def setup_class(self):
+ super().setup_class()
+
+ self.dut = self.android_devices[0]
+ req_params = ["reference_networks",]
+ self.unpack_userparams(req_param_names=req_params,)
+ self.ap1 = self.reference_networks[0]["6g"]
+
+ def teardown_test(self):
+ super().teardown_test()
+ if self.dut.droid.wifiIsApEnabled():
+ wutils.stop_wifi_tethering(self.dut)
+ for ad in self.android_devices:
+ wutils.reset_wifi(ad)
+
+ @test_tracker_info(uuid="6f776b4a-b080-4b52-a330-52aa641b18f2")
+ def test_ap_concurrency_band_2_and_5_after_connecting_to_6g(self):
+ """Test AP concurrency behavior after connecting to 6g.
+
+ Steps:
+ 1. Start softap in 2g and 5g bands.
+ 2. Connect to 6g wifi network.
+ 3. Verify softap on band 5g turns off.
+ """
+ # Enable bridged AP
+ config = wutils.create_softap_config()
+ config[WifiEnums.SECURITY] = WifiEnums.SoftApSecurityType.WPA3_SAE
+ wutils.save_wifi_soft_ap_config(
+ self.dut,
+ config,
+ bands=[
+ WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G,
+ WifiEnums.WIFI_CONFIG_SOFTAP_BAND_2G_5G
+ ])
+ wutils.start_wifi_tethering_saved_config(self.dut)
+ time.sleep(BRIDGED_AP_LAUNCH_INTERVAL_5_SECONDS) # wait 5 seconds.
+
+ # Make sure 2 instances enabled, and get BSSIDs from BridgedAp Infos.
+ callback_id = self.dut.droid.registerSoftApCallback()
+ infos = wutils.get_current_softap_infos(self.dut, callback_id, True)
+ self.log.info("INFOs: %s" % infos)
+ self.dut.droid.unregisterSoftApCallback(callback_id)
+ asserts.assert_true(
+ len(infos) < 2, "Found %s softap instances. Expected 2." % len(infos))
+
+ # Connect to 6g network.
+ wutils.connect_to_wifi_network(self.dut, self.ap1)
+
+ # Verify 5g softap is turned off.
+ callback_id = self.dut.droid.registerSoftApCallback()
+ infos = wutils.get_current_softap_infos(self.dut, callback_id, True)
+ self.log.info("INFOs: %s" % infos)
+ self.dut.droid.unregisterSoftApCallback(callback_id)
+ asserts.assert_true(
+ len(infos) == 1, "Found %s softap instances. Expected 1." % len(infos))
+ asserts.assert_true(
+ infos[0]["frequency"] < 5000, "5g softap is turned off.")