Merge "Rewrite the power measurement retry loop" am: e6e7030c75
am: a5f9a0d432
Change-Id: I4167b2cb33ff9da36753c32a47c7b9ce7db6e4bd
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
index 8429cf6..5ad47bf 100644
--- a/PREUPLOAD.cfg
+++ b/PREUPLOAD.cfg
@@ -1,5 +1,6 @@
[Hook Scripts]
acts_base_class_test = ./acts/framework/tests/acts_base_class_test.py
+acts_adb_test = ./acts/framework/tests/acts_adb_test.py
acts_android_device_test = ./acts/framework/tests/acts_android_device_test.py
acts_asserts_test = ./acts/framework/tests/acts_asserts_test.py
acts_base_class_test = ./acts/framework/tests/acts_base_class_test.py
@@ -14,7 +15,10 @@
acts_import_test_utils_test = ./acts/framework/tests/acts_import_test_utils_test.py
acts_import_unit_test = ./acts/framework/tests/acts_import_unit_test.py
acts_relay_controller_test = ./acts/framework/tests/acts_relay_controller_test.py
+commit_message_hook = ./tools/commit_message_check.py
yapf_hook = ./tools/yapf_checker.py
+commit_message_check = ./tools/commit_message_check.py
+lab_test = ./tools/lab/test_main.py
[Builtin Hooks]
commit_msg_bug_field = true
diff --git a/acts/README.md b/acts/README.md
index bf0ec48..caa2f0c 100644
--- a/acts/README.md
+++ b/acts/README.md
@@ -20,6 +20,19 @@
[Python Style Guide](https://google.github.io/styleguide/pyguide.html), and
it is recommended for all new test cases.
+System dependencies:
+ - adb
+ - python3.4+
+ - python3.4-setuptools
+
+Python dependencies (installed automatically by setup.py):
+ - future
+ - pyserial
+
+To run unit tests:
+$ python3 setup.py test
+$ python setup.py test
+
## ACTS Execution Flow Overview
Below is a high level view of the ACTS flow:
@@ -57,9 +70,12 @@
displayed. Check the "Always" box and click "Yes".
## ACTS Setup
-From the ACTS directory, run setup
-- `$ sudo python setup.py develop`
+1. Install the system dependencies.
+ On Ubuntu, sudo apt-get install python3.4 python3-setuptools
+2. Run "python3.4 setup.py install" with elevated permissions
+3. To verify ACTS is ready to go, at the location for README, and run:
+ cd tests/ && act.py -c acts_sanity_test_config.json -tc IntegrationTest
After installation, `act.py` will be in usr/bin and can be called as command
line utilities. Components in ACTS are importable under the package "acts."
@@ -71,34 +87,15 @@
>>> device_list = android_device.get_all_instances()
```
-## Verifying Setup
-To verify the host and device are ready, from the frameworks folder run:
+## Breaking Down a Sample Command
-- `$ act.py -c sample_config.json -tb SampleTestBed -tc SampleTest`
-
-If the above command executed successfully, the ouput should look something
-similar to following:
-
-```
-[SampleTestBed] 07-22 15:23:50.323 INFO ==========> SampleTest <==========
-[SampleTestBed] 07-22 15:23:50.327 INFO [Test Case] test_make_toast
-[SampleTestBed] 07-22 15:23:50.334 INFO [Test Case] test_make_toast PASS
-[SampleTestBed] 07-22 15:23:50.338 INFO Summary for test class SampleTest:
-Requested 1, Executed 1, Passed 1, Failed 0, Skipped 0
-[SampleTestBed] 07-22 15:23:50.338 INFO Summary for test run
-SampleTestBed@07-22-2015_1-23-44-096: Requested 1, Executed 1, Passed 1,
-Failed 0, Skipped 0
-```
-
-By default, all logs are saved in `/tmp/logs`
-
-## Breaking Down the Example
-Below are the components of the command run for the SampleTest:
+Above, the command `act.py -c acts_sanity_test_config.json -tc IntegrationTest`
+was run to verify ACTS was properly set up.
+Below are the components of that command:
- `acts.py`: is the script that runs the test
-- -c sample_config: is the flag and name of the configuration file to be used
-in the test
-- -tb StampleTestBed: is the flag and name of the test bed to be used
-- -tc SampleTest: is the name of the test case
+- -c acts_sanity_test_config: is the flag and name of the configuration file
+to be used in the test
+- -tc IntegrationTest: is the name of the test case
### Configuration Files
To run tests, required information must be provided via a json-formatted
@@ -133,8 +130,8 @@
and are created based on the provided configuration file.
Test classes must also contain an iterable member self.tests that lists the
-test case names within the class. More on this is discussed after the following
-code snippet.
+test case names within the class. More on this is discussed after the
+following code snippet.
```
from acts.base_test import BaseTestClass
diff --git a/acts/framework/README b/acts/framework/README
deleted file mode 100644
index 43c98aa..0000000
--- a/acts/framework/README
+++ /dev/null
@@ -1,21 +0,0 @@
-This package includes the Android Comms Testing Suite (ACTS) alpha release
-
-System dependencies:
- - adb
- - python3.4+
- - python3.4-setuptools
-
-Python dependencies (installed automatically by setup.py):
- - future
- - pyserial
-
-To run unit tests:
-$ python3 setup.py test
-$ python setup.py test
-
-Setup:
- 1. Install the system dependencies.
- On Ubuntu, sudo apt-get install python3.4 python3-setuptools
- 2. Run "python3.4 setup.py install" with elevated permissions
- 3. To verify ACTS is ready to go, at the location for README, and run:
- cd tests/ && act.py -c acts_sanity_test_config.json -tc IntegrationTest
diff --git a/acts/framework/acts/controllers/adb.py b/acts/framework/acts/controllers/adb.py
index 5524700..0a652a3 100644
--- a/acts/framework/acts/controllers/adb.py
+++ b/acts/framework/acts/controllers/adb.py
@@ -29,6 +29,9 @@
DEFAULT_ADB_TIMEOUT = 60
DEFAULT_ADB_PULL_TIMEOUT = 180
+# Uses a regex to be backwards compatible with previous versions of ADB
+# (N and above add the serial to the error msg).
+DEVICE_NOT_FOUND_REGEX = re.compile('^error: device (?:\'.*?\' )?not found')
def parsing_parcel_output(output):
@@ -107,31 +110,28 @@
def _exec_cmd(self, cmd, ignore_status=False, timeout=DEFAULT_ADB_TIMEOUT):
"""Executes adb commands in a new shell.
- This is specific to executing adb binary because stderr is not a good
- indicator of cmd execution status.
+ This is specific to executing adb commands.
Args:
- cmds: A string that is the adb command to execute.
+ cmd: A string that is the adb command to execute.
Returns:
- The output of the adb command run if exit code is 0.
+ The stdout of the adb command.
Raises:
- AdbError is raised if the adb command exit code is not 0.
+ AdbError is raised if adb cannot find the device.
"""
result = job.run(cmd, ignore_status=True, timeout=timeout)
ret, out, err = result.exit_status, result.stdout, result.stderr
logging.debug("cmd: %s, stdout: %s, stderr: %s, ret: %s", cmd, out,
err, ret)
-
- if ret == 0 or ignore_status:
- if "Result: Parcel" in out:
- return parsing_parcel_output(out)
- else:
- return out
- else:
+ if not ignore_status and ret == 1 and DEVICE_NOT_FOUND_REGEX.match(err):
raise AdbError(cmd=cmd, stdout=out, stderr=err, ret_code=ret)
+ elif "Result: Parcel" in out:
+ return parsing_parcel_output(out)
+ else:
+ return out
def _exec_adb_cmd(self, name, arg_str, **kwargs):
return self._exec_cmd(' '.join((self.adb_str, name, arg_str)),
diff --git a/acts/framework/acts/controllers/android_device.py b/acts/framework/acts/controllers/android_device.py
index b5ac863..29e2be0 100755
--- a/acts/framework/acts/controllers/android_device.py
+++ b/acts/framework/acts/controllers/android_device.py
@@ -791,18 +791,15 @@
Returns:
True if package is installed. False otherwise.
"""
+
try:
- out = self.adb.shell(
- 'pm list packages | grep -w "package:%s"' % package_name,
- ignore_status=False)
- if package_name in out:
- self.log.debug("apk %s is installed", package_name)
- return True
- else:
- self.log.debug("apk %s is not installed, query returns %s",
- package_name, out)
- return False
- except:
+ return bool(
+ self.adb.shell('pm list packages | grep -w "package:%s"' %
+ package_name))
+
+ except Exception as err:
+ self.log.error('Could not determine if %s is installed. '
+ 'Received error:\n%s', package_name, err)
return False
def is_sl4a_installed(self):
diff --git a/acts/framework/acts/controllers/native.py b/acts/framework/acts/controllers/native.py
index 7c9df2b..aa987b1 100644
--- a/acts/framework/acts/controllers/native.py
+++ b/acts/framework/acts/controllers/native.py
@@ -14,7 +14,7 @@
# License for the specific language governing permissions and limitations under
# the License.
-from acts.controllers.android import Android
+from acts.controllers.sl4a_client import Sl4aClient
import json
import os
import socket
@@ -46,13 +46,12 @@
i += 1
-class NativeAndroid(Android):
+class NativeAndroid(Sl4aClient):
COUNTER = IDCounter()
def _rpc(self, method, *args):
- self.lock.acquire()
- apiid = next(NativeAndroid.COUNTER)
- self.lock.release()
+ with self._lock:
+ apiid = next(self._counter)
data = {'id': apiid, 'method': method, 'params': args}
request = json.dumps(data)
self.client.write(request.encode("utf8") + b'\n')
@@ -61,9 +60,8 @@
if not response:
raise SL4NProtocolError(SL4NProtocolError.NO_RESPONSE_FROM_SERVER)
#TODO: (tturney) fix the C side from sending \x00 char over the socket.
- result = json.loads(str(response,
- encoding="utf8").rstrip().replace("\x00", ""))
-
+ result = json.loads(
+ str(response, encoding="utf8").rstrip().replace("\x00", ""))
if result['error']:
raise SL4NAPIError(result['error'])
if result['id'] != apiid:
diff --git a/acts/framework/acts/controllers/native_android_device.py b/acts/framework/acts/controllers/native_android_device.py
index 00662b3..cbe3237 100644
--- a/acts/framework/acts/controllers/native_android_device.py
+++ b/acts/framework/acts/controllers/native_android_device.py
@@ -15,7 +15,7 @@
# limitations under the License.
from acts.controllers.android_device import AndroidDevice
-from acts.controllers.utils_lib import host_utils
+from acts.controllers.utils_lib import host_utils
import acts.controllers.native as native
from subprocess import call
@@ -29,8 +29,8 @@
def create(configs):
- logger = logging.getLogger()
- ads = get_instances(configs, logger)
+ logger = logging
+ ads = get_instances(configs)
for ad in ads:
try:
ad.get_droid()
@@ -43,7 +43,7 @@
pass
-def get_instances(serials, logger=None):
+def get_instances(serials, ):
"""Create AndroidDevice instances from a list of serials.
Args:
@@ -55,7 +55,7 @@
"""
results = []
for s in serials:
- results.append(NativeAndroidDevice(s, logger=logger))
+ results.append(NativeAndroidDevice(s))
return results
@@ -97,12 +97,10 @@
if not self.h_port or not host_utils.is_port_available(self.h_port):
self.h_port = host_utils.get_available_host_port()
self.adb.tcp_forward(self.h_port, self.d_port)
- pid = self.adb.shell("ps | grep sl4n | awk '{print $2}'").decode(
- 'ascii')
+ pid = self.adb.shell("pidof -s sl4n", ignore_status=True)
while (pid):
self.adb.shell("kill {}".format(pid))
- pid = self.adb.shell("ps | grep sl4n | awk '{print $2}'").decode(
- 'ascii')
+ pid = self.adb.shell("pidof -s sl4n", ignore_status=True)
call(
["adb -s " + self.serial + " shell sh -c \"/system/bin/sl4n\" &"],
shell=True)
@@ -127,6 +125,7 @@
existing uid to a new session.
"""
droid = native.NativeAndroid(port=self.h_port)
+ droid.open()
if droid.uid in self._droid_sessions:
raise bt.SL4NException(("SL4N returned an existing uid for a "
"new session. Abort."))
diff --git a/acts/framework/acts/test_runner.py b/acts/framework/acts/test_runner.py
index b47a47b..aa81976 100644
--- a/acts/framework/acts/test_runner.py
+++ b/acts/framework/acts/test_runner.py
@@ -287,8 +287,8 @@
for ctrl_name in keys.Config.builtin_controller_names.value:
if ctrl_name in self.testbed_configs:
module_name = keys.get_module_name(ctrl_name)
- module = importlib.import_module("acts.controllers.%s" %
- module_name)
+ module = importlib.import_module(
+ "acts.controllers.%s" % module_name)
builtin_controllers.append(module)
return builtin_controllers
@@ -315,8 +315,8 @@
attr))
if not getattr(module, attr):
raise signals.ControllerError(
- "Controller interface %s in %s cannot be null." % (
- attr, module.__name__))
+ "Controller interface %s in %s cannot be null." %
+ (attr, module.__name__))
def register_controller(self, module, required=True):
"""Registers an ACTS controller module for a test run.
@@ -434,8 +434,8 @@
# tracking controller objs in test_run_info.
if builtin:
self.test_run_info[module_ref_name] = objects
- self.log.debug("Found %d objects for controller %s", len(objects),
- module_config_name)
+ self.log.debug("Found %d objects for controller %s",
+ len(objects), module_config_name)
destroy_func = module.destroy
self.controller_destructors[module_ref_name] = destroy_func
return objects
diff --git a/acts/framework/acts/test_utils/bt/bt_gatt_utils.py b/acts/framework/acts/test_utils/bt/bt_gatt_utils.py
index a6d5b81..3f80d68 100644
--- a/acts/framework/acts/test_utils/bt/bt_gatt_utils.py
+++ b/acts/framework/acts/test_utils/bt/bt_gatt_utils.py
@@ -40,11 +40,12 @@
def setup_gatt_connection(cen_ad,
mac_address,
autoconnect,
- transport=gatt_transport['auto']):
+ transport=gatt_transport['auto'],
+ opportunistic=False):
gatt_callback = cen_ad.droid.gattCreateGattCallback()
log.info("Gatt Connect to mac address {}.".format(mac_address))
bluetooth_gatt = cen_ad.droid.gattClientConnectGatt(
- gatt_callback, mac_address, autoconnect, transport,
+ gatt_callback, mac_address, autoconnect, transport, opportunistic,
gatt_phy_mask['1m_mask'])
expected_event = gatt_cb_strings['gatt_conn_change'].format(gatt_callback)
try:
@@ -66,6 +67,13 @@
return bluetooth_gatt, gatt_callback
+def close_gatt_client(cen_ad, bluetooth_gatt):
+ try:
+ cen_ad.droid.gattClientClose(bluetooth_gatt)
+ except Exception:
+ log.debug("Failed to close gatt client.")
+
+
def disconnect_gatt_connection(cen_ad, bluetooth_gatt, gatt_callback):
cen_ad.droid.gattClientDisconnect(bluetooth_gatt)
wait_for_gatt_disconnect_event(cen_ad, gatt_callback)
@@ -92,7 +100,8 @@
per_ad,
transport=gatt_transport['le'],
mac_address=None,
- autoconnect=False):
+ autoconnect=False,
+ opportunistic=False):
adv_callback = None
if mac_address is None:
if transport == gatt_transport['le']:
@@ -106,7 +115,7 @@
mac_address = per_ad.droid.bluetoothGetLocalAddress()
adv_callback = None
bluetooth_gatt, gatt_callback = setup_gatt_connection(
- cen_ad, mac_address, autoconnect, transport)
+ cen_ad, mac_address, autoconnect, transport, opportunistic)
return bluetooth_gatt, gatt_callback, adv_callback
diff --git a/acts/framework/acts/test_utils/bt/native_bt_test_utils.py b/acts/framework/acts/test_utils/bt/native_bt_test_utils.py
index d070f13..9be24f0 100644
--- a/acts/framework/acts/test_utils/bt/native_bt_test_utils.py
+++ b/acts/framework/acts/test_utils/bt/native_bt_test_utils.py
@@ -25,15 +25,14 @@
def setup_native_bluetooth(native_devices):
for n in native_devices:
droid = n.droid
- pid = n.adb.shell("ps | grep bluetoothtbd | awk '{print $2}'").decode(
- 'ascii')
+ pid = n.adb.shell("pidof -s bluetoothtbd")
if not pid:
call(
["adb -s " + n.serial + " shell sh -c \"bluetoothtbd\" &"],
shell=True)
- droid.BluetoothBinderInitInterface()
+ droid.BtBinderInitInterface()
time.sleep(5) #temporary sleep statement
- droid.BluetoothBinderEnable()
+ droid.BtBinderEnable()
time.sleep(5) #temporary sleep statement
- droid.BluetoothBinderRegisterBLE()
+ droid.BtBinderRegisterBLE()
time.sleep(5) #temporary sleep statement
diff --git a/acts/framework/acts/test_utils/net/connectivity_const.py b/acts/framework/acts/test_utils/net/connectivity_const.py
index de8de47..89bdb2c 100644
--- a/acts/framework/acts/test_utils/net/connectivity_const.py
+++ b/acts/framework/acts/test_utils/net/connectivity_const.py
@@ -39,6 +39,8 @@
NETWORK_CB_KEY_MAX_MS_TO_LIVE = "maxMsToLive"
NETWORK_CB_KEY_RSSI = "rssi"
NETWORK_CB_KEY_INTERFACE_NAME = "interfaceName"
+NETWORK_CB_KEY_CREATE_TS = "creation_timestamp"
+NETWORK_CB_KEY_CURRENT_TS = "current_timestamp"
# Constants for VPN connection status
VPN_STATE_DISCONNECTED = 0
diff --git a/acts/framework/acts/test_utils/tel/tel_test_utils.py b/acts/framework/acts/test_utils/tel/tel_test_utils.py
index e97a406..d02307a 100644
--- a/acts/framework/acts/test_utils/tel/tel_test_utils.py
+++ b/acts/framework/acts/test_utils/tel/tel_test_utils.py
@@ -3886,10 +3886,12 @@
Phone not in airplane mode.
"""
result = True
+
if not toggle_airplane_mode(log, ad, False, False):
ad.log.error("Fail to turn off airplane mode")
result = False
set_wifi_to_default(log, ad)
+
try:
if ad.droid.telecomIsInCall():
ad.droid.telecomEndCall()
diff --git a/acts/framework/acts/test_utils/wifi/aware/AwareBaseTest.py b/acts/framework/acts/test_utils/wifi/aware/AwareBaseTest.py
new file mode 100644
index 0000000..d95a3eb
--- /dev/null
+++ b/acts/framework/acts/test_utils/wifi/aware/AwareBaseTest.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2017 - Google
+#
+# 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 asserts
+from acts.base_test import BaseTestClass
+from acts.test_utils.wifi import wifi_test_utils as wutils
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+
+
+class AwareBaseTest(BaseTestClass):
+ def __init__(self, controllers):
+ BaseTestClass.__init__(self, controllers)
+
+ # message ID counter to make sure all uses are unique
+ msg_id = 0
+
+ # offset (in seconds) to separate the start-up of multiple devices.
+ # De-synchronizes the start-up time so that they don't start and stop scanning
+ # at the same time - which can lead to very long clustering times.
+ device_startup_offset = 2
+
+ def setup_test(self):
+ required_params = ("aware_default_power_mode", )
+ self.unpack_userparams(required_params)
+
+ for ad in self.android_devices:
+ wutils.wifi_toggle_state(ad, True)
+ ad.droid.wifiP2pClose()
+ aware_avail = ad.droid.wifiIsAwareAvailable()
+ if not aware_avail:
+ self.log.info('Aware not available. Waiting ...')
+ autils.wait_for_event(ad, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
+ ad.ed.pop_all(aconsts.BROADCAST_WIFI_AWARE_AVAILABLE) # clear-out extras
+ ad.aware_capabilities = autils.get_aware_capabilities(ad)
+ self.reset_device_parameters(ad)
+ self.reset_device_statistics(ad)
+ self.set_power_mode_parameters(ad)
+
+ def teardown_test(self):
+ for ad in self.android_devices:
+ ad.droid.wifiP2pClose()
+ ad.droid.wifiAwareDestroyAll()
+ self.reset_device_parameters(ad)
+ autils.validate_forbidden_callbacks(ad)
+
+ def reset_device_parameters(self, ad):
+ """Reset device configurations which may have been set by tests. Should be
+ done before tests start (in case previous one was killed without tearing
+ down) and after they end (to leave device in usable state).
+
+ Args:
+ ad: device to be reset
+ """
+ ad.adb.shell("cmd wifiaware reset")
+
+ def reset_device_statistics(self, ad):
+ """Reset device statistics.
+
+ Args:
+ ad: device to be reset
+ """
+ ad.adb.shell("cmd wifiaware native_cb get_cb_count --reset")
+
+ def set_power_mode_parameters(self, ad):
+ """Set the power configuration DW parameters for the device based on any
+ configuration overrides (if provided)"""
+ if self.aware_default_power_mode == "INTERACTIVE":
+ autils.config_dw_high_power(ad)
+ elif self.aware_default_power_mode == "NON_INTERACTIVE":
+ autils.config_dw_low_power(ad)
+ else:
+ asserts.assert_false(
+ "The 'aware_default_power_mode' configuration must be INTERACTIVE or "
+ "NON_INTERACTIVE"
+ )
+
+ def get_next_msg_id(self):
+ """Increment the message ID and returns the new value. Guarantees that
+ each call to the method returns a unique value.
+
+ Returns: a new message id value.
+ """
+ self.msg_id = self.msg_id + 1
+ return self.msg_id
diff --git a/acts/framework/acts/test_utils/wifi/aware/__init__.py b/acts/framework/acts/test_utils/wifi/aware/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts/framework/acts/test_utils/wifi/aware/__init__.py
diff --git a/acts/framework/acts/test_utils/wifi/wifi_aware_const.py b/acts/framework/acts/test_utils/wifi/aware/aware_const.py
similarity index 66%
rename from acts/framework/acts/test_utils/wifi/wifi_aware_const.py
rename to acts/framework/acts/test_utils/wifi/aware/aware_const.py
index 7e495f5..a7574a4 100644
--- a/acts/framework/acts/test_utils/wifi/wifi_aware_const.py
+++ b/acts/framework/acts/test_utils/wifi/aware/aware_const.py
@@ -15,6 +15,16 @@
# limitations under the License.
######################################################
+# Aware DW (Discovery Window) power mode values
+######################################################
+
+DW_24_INTERACTIVE = 1
+DW_5_INTERACTIVE = 1
+
+DW_24_NON_INTERACTIVE = 4
+DW_5_NON_INTERACTIVE = 0
+
+######################################################
# Broadcast events
######################################################
BROADCAST_WIFI_AWARE_AVAILABLE = "WifiAwareAvailable"
@@ -31,29 +41,22 @@
CONFIG_KEY_ENABLE_IDEN_CB = "EnableIdentityChangeCallback"
######################################################
-# PublishConfig keys
+# Publish & Subscribe Config keys
######################################################
-PUBLISH_KEY_SERVICE_NAME = "ServiceName"
-PUBLISH_KEY_SSI = "ServiceSpecificInfo"
-PUBLISH_KEY_MATCH_FILTER = "MatchFilter"
-PUBLISH_KEY_TYPE = "PublishType"
-PUBLISH_KEY_COUNT = "PublishCount"
-PUBLISH_KEY_TTL = "TtlSec"
-PUBLISH_KEY_TERM_CB_ENABLED = "TerminateNotificationEnabled"
+DISCOVERY_KEY_SERVICE_NAME = "ServiceName"
+DISCOVERY_KEY_SSI = "ServiceSpecificInfo"
+DISCOVERY_KEY_MATCH_FILTER = "MatchFilter"
+DISCOVERY_KEY_MATCH_FILTER_LIST = "MatchFilterList"
+DISCOVERY_KEY_DISCOVERY_TYPE = "DiscoveryType"
+DISCOVERY_KEY_TTL = "TtlSec"
+DISCOVERY_KEY_TERM_CB_ENABLED = "TerminateNotificationEnabled"
-######################################################
-# SubscribeConfig keys
-######################################################
+PUBLISH_TYPE_UNSOLICITED = 0
+PUBLISH_TYPE_SOLICITED = 1
-SUBSCRIBE_KEY_SERVICE_NAME = "ServiceName"
-SUBSCRIBE_KEY_SSI = "ServiceSpecificInfo"
-SUBSCRIBE_KEY_MATCH_FILTER = "MatchFilter"
-SUBSCRIBE_KEY_TYPE = "SubscribeType"
-SUBSCRIBE_KEY_COUNT = "SubscribeCount"
-SUBSCRIBE_KEY_TTL = "TtlSec"
-SUBSCRIBE_KEY_STYLE = "MatchStyle"
-SUBSCRIBE_KEY_ENABLE_TERM_CB = "EnableTerminateNotification"
+SUBSCRIBE_TYPE_PASSIVE = 0
+SUBSCRIBE_TYPE_ACTIVE = 1
######################################################
# WifiAwareAttachCallback events
@@ -92,6 +95,7 @@
SESSION_CB_KEY_PEER_ID = "peerId"
SESSION_CB_KEY_SERVICE_SPECIFIC_INFO = "serviceSpecificInfo"
SESSION_CB_KEY_MATCH_FILTER = "matchFilter"
+SESSION_CB_KEY_MATCH_FILTER_LIST = "matchFilterList"
SESSION_CB_KEY_MESSAGE = "message"
SESSION_CB_KEY_MESSAGE_ID = "messageId"
SESSION_CB_KEY_MESSAGE_AS_STRING = "messageAsString"
@@ -113,6 +117,32 @@
RTT_LISTENER_CB_KEY_DESCRIPTION = "description"
######################################################
+# Capabilities keys
+######################################################
+
+CAP_MAX_CONCURRENT_AWARE_CLUSTERS = "maxConcurrentAwareClusters"
+CAP_MAX_PUBLISHES = "maxPublishes"
+CAP_MAX_SUBSCRIBES = "maxSubscribes"
+CAP_MAX_SERVICE_NAME_LEN = "maxServiceNameLen"
+CAP_MAX_MATCH_FILTER_LEN = "maxMatchFilterLen"
+CAP_MAX_TOTAL_MATCH_FILTER_LEN = "maxTotalMatchFilterLen"
+CAP_MAX_SERVICE_SPECIFIC_INFO_LEN = "maxServiceSpecificInfoLen"
+CAP_MAX_EXTENDED_SERVICE_SPECIFIC_INFO_LEN = "maxExtendedServiceSpecificInfoLen"
+CAP_MAX_NDI_INTERFACES = "maxNdiInterfaces"
+CAP_MAX_NDP_SESSIONS = "maxNdpSessions"
+CAP_MAX_APP_INFO_LEN = "maxAppInfoLen"
+CAP_MAX_QUEUED_TRANSMIT_MESSAGES = "maxQueuedTransmitMessages"
+CAP_MAX_SUBSCRIBE_INTERFACE_ADDRESSES = "maxSubscribeInterfaceAddresses"
+CAP_SUPPORTED_CIPHER_SUITES = "supportedCipherSuites"
+
+######################################################
+
+# Aware NDI (NAN data-interface) name prefix
+AWARE_NDI_PREFIX = "aware_data"
+
+# Aware discovery channels
+AWARE_DISCOVERY_CHANNEL_24_BAND = 6
+AWARE_DISCOVERY_CHANNEL_5_BAND = 149
# Aware Data-Path Constants
DATA_PATH_INITIATOR = 0
@@ -120,3 +150,16 @@
# Maximum send retry
MAX_TX_RETRIES = 5
+
+# Callback keys (for 'adb shell cmd wifiaware native_cb get_cb_count')
+CB_EV_CLUSTER = "0"
+CB_EV_DISABLED = "1"
+CB_EV_PUBLISH_TERMINATED = "2"
+CB_EV_SUBSCRIBE_TERMINATED = "3"
+CB_EV_MATCH = "4"
+CB_EV_MATCH_EXPIRED = "5"
+CB_EV_FOLLOWUP_RECEIVED = "6"
+CB_EV_TRANSMIT_FOLLOWUP = "7"
+CB_EV_DATA_PATH_REQUEST = "8"
+CB_EV_DATA_PATH_CONFIRM = "9"
+CB_EV_DATA_PATH_TERMINATED = "10"
diff --git a/acts/framework/acts/test_utils/wifi/aware/aware_test_utils.py b/acts/framework/acts/test_utils/wifi/aware/aware_test_utils.py
new file mode 100644
index 0000000..9ed704f
--- /dev/null
+++ b/acts/framework/acts/test_utils/wifi/aware/aware_test_utils.py
@@ -0,0 +1,672 @@
+#!/usr/bin/env python3.4
+#
+# Copyright 2017 - Google
+#
+# 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 base64
+import json
+import queue
+import re
+import statistics
+import time
+from acts import asserts
+
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+
+# arbitrary timeout for events
+EVENT_TIMEOUT = 10
+
+# semi-arbitrary timeout for network formation events. Based on framework
+# timeout for NDP (NAN data-path) negotiation to be completed.
+EVENT_NDP_TIMEOUT = 20
+
+# number of second to 'reasonably' wait to make sure that devices synchronize
+# with each other - useful for OOB test cases, where the OOB discovery would
+# take some time
+WAIT_FOR_CLUSTER = 5
+
+
+def decorate_event(event_name, id):
+ return '%s_%d' % (event_name, id)
+
+
+def wait_for_event(ad, event_name, timeout=EVENT_TIMEOUT):
+ """Wait for the specified event or timeout.
+
+ Args:
+ ad: The android device
+ event_name: The event to wait on
+ timeout: Number of seconds to wait
+ Returns:
+ The event (if available)
+ """
+ prefix = ''
+ if hasattr(ad, 'pretty_name'):
+ prefix = '[%s] ' % ad.pretty_name
+ try:
+ event = ad.ed.pop_event(event_name, timeout)
+ ad.log.info('%s%s: %s', prefix, event_name, event['data'])
+ return event
+ except queue.Empty:
+ ad.log.info('%sTimed out while waiting for %s', prefix, event_name)
+ asserts.fail(event_name)
+
+def wait_for_event_with_keys(ad, event_name, timeout=EVENT_TIMEOUT, *keyvalues):
+ """Wait for the specified event contain the key/value pairs or timeout
+
+ Args:
+ ad: The android device
+ event_name: The event to wait on
+ timeout: Number of seconds to wait
+ keyvalues: (kay, value) pairs
+ Returns:
+ The event (if available)
+ """
+ def filter_callbacks(event, keyvalues):
+ for keyvalue in keyvalues:
+ key, value = keyvalue
+ if event['data'][key] != value:
+ return False
+ return True
+
+ prefix = ''
+ if hasattr(ad, 'pretty_name'):
+ prefix = '[%s] ' % ad.pretty_name
+ try:
+ event = ad.ed.wait_for_event(event_name, filter_callbacks, timeout,
+ keyvalues)
+ ad.log.info('%s%s: %s', prefix, event_name, event['data'])
+ return event
+ except queue.Empty:
+ ad.log.info('%sTimed out while waiting for %s (%s)', prefix, event_name,
+ keyvalues)
+ asserts.fail(event_name)
+
+def fail_on_event(ad, event_name, timeout=EVENT_TIMEOUT):
+ """Wait for a timeout period and looks for the specified event - fails if it
+ is observed.
+
+ Args:
+ ad: The android device
+ event_name: The event to wait for (and fail on its appearance)
+ """
+ prefix = ''
+ if hasattr(ad, 'pretty_name'):
+ prefix = '[%s] ' % ad.pretty_name
+ try:
+ event = ad.ed.pop_event(event_name, timeout)
+ ad.log.info('%sReceived unwanted %s: %s', prefix, event_name, event['data'])
+ asserts.fail(event_name, extras=event)
+ except queue.Empty:
+ ad.log.info('%s%s not seen (as expected)', prefix, event_name)
+ return
+
+def fail_on_event_with_keys(ad, event_name, timeout=EVENT_TIMEOUT, *keyvalues):
+ """Wait for a timeout period and looks for the specified event which contains
+ the key/value pairs - fails if it is observed.
+
+ Args:
+ ad: The android device
+ event_name: The event to wait on
+ timeout: Number of seconds to wait
+ keyvalues: (kay, value) pairs
+ """
+ def filter_callbacks(event, keyvalues):
+ for keyvalue in keyvalues:
+ key, value = keyvalue
+ if event['data'][key] != value:
+ return False
+ return True
+
+ prefix = ''
+ if hasattr(ad, 'pretty_name'):
+ prefix = '[%s] ' % ad.pretty_name
+ try:
+ event = ad.ed.wait_for_event(event_name, filter_callbacks, timeout,
+ keyvalues)
+ ad.log.info('%sReceived unwanted %s: %s', prefix, event_name, event['data'])
+ asserts.fail(event_name, extras=event)
+ except queue.Empty:
+ ad.log.info('%s%s (%s) not seen (as expected)', prefix, event_name,
+ keyvalues)
+ return
+
+def verify_no_more_events(ad, timeout=EVENT_TIMEOUT):
+ """Verify that there are no more events in the queue.
+ """
+ prefix = ''
+ if hasattr(ad, 'pretty_name'):
+ prefix = '[%s] ' % ad.pretty_name
+ should_fail = False
+ try:
+ while True:
+ event = ad.ed.pop_events('.*', timeout, freq=0)
+ ad.log.info('%sQueue contains %s', prefix, event)
+ should_fail = True
+ except queue.Empty:
+ if should_fail:
+ asserts.fail('%sEvent queue not empty' % prefix)
+ ad.log.info('%sNo events in the queue (as expected)', prefix)
+ return
+
+
+def encode_list(list_of_objects):
+ """Converts the list of strings or bytearrays to a list of b64 encoded
+ bytearrays.
+
+ A None object is treated as a zero-length bytearray.
+
+ Args:
+ list_of_objects: A list of strings or bytearray objects
+ Returns: A list of the same objects, converted to bytes and b64 encoded.
+ """
+ encoded_list = []
+ for obj in list_of_objects:
+ if obj is None:
+ obj = bytes()
+ if isinstance(obj, str):
+ encoded_list.append(base64.b64encode(bytes(obj, 'utf-8')).decode('utf-8'))
+ else:
+ encoded_list.append(base64.b64encode(obj).decode('utf-8'))
+ return encoded_list
+
+
+def decode_list(list_of_b64_strings):
+ """Converts the list of b64 encoded strings to a list of bytearray.
+
+ Args:
+ list_of_b64_strings: list of strings, each of which is b64 encoded array
+ Returns: a list of bytearrays.
+ """
+ decoded_list = []
+ for str in list_of_b64_strings:
+ decoded_list.append(base64.b64decode(str))
+ return decoded_list
+
+
+def construct_max_match_filter(max_size):
+ """Constructs a maximum size match filter that fits into the 'max_size' bytes.
+
+ Match filters are a set of LVs (Length, Value pairs) where L is 1 byte. The
+ maximum size match filter will contain max_size/2 LVs with all Vs (except
+ possibly the last one) of 1 byte, the last V may be 2 bytes for odd max_size.
+
+ Args:
+ max_size: Maximum size of the match filter.
+ Returns: an array of bytearrays.
+ """
+ mf_list = []
+ num_lvs = max_size // 2
+ for i in range(num_lvs - 1):
+ mf_list.append(bytes([i]))
+ if (max_size % 2 == 0):
+ mf_list.append(bytes([255]))
+ else:
+ mf_list.append(bytes([254, 255]))
+ return mf_list
+
+
+def assert_equal_strings(first, second, msg=None, extras=None):
+ """Assert equality of the string operands - where None is treated as equal to
+ an empty string (''), otherwise fail the test.
+
+ Error message is "first != second" by default. Additional explanation can
+ be supplied in the message.
+
+ Args:
+ first, seconds: The strings that are evaluated for equality.
+ msg: A string that adds additional info about the failure.
+ extras: An optional field for extra information to be included in
+ test result.
+ """
+ if first == None:
+ first = ''
+ if second == None:
+ second = ''
+ asserts.assert_equal(first, second, msg, extras)
+
+
+def get_aware_capabilities(ad):
+ """Get the Wi-Fi Aware capabilities from the specified device. The
+ capabilities are a dictionary keyed by aware_const.CAP_* keys.
+
+ Args:
+ ad: the Android device
+ Returns: the capability dictionary.
+ """
+ return json.loads(ad.adb.shell('cmd wifiaware state_mgr get_capabilities'))
+
+def get_wifi_mac_address(ad):
+ """Get the Wi-Fi interface MAC address as a upper-case string of hex digits
+ without any separators (e.g. ':').
+
+ Args:
+ ad: Device on which to run.
+ """
+ return ad.droid.wifiGetConnectionInfo()['mac_address'].upper().replace(
+ ':', '')
+
+def validate_forbidden_callbacks(ad, limited_cb=None):
+ """Validate that the specified callbacks have not been called more then permitted.
+
+ In addition to the input configuration also validates that forbidden callbacks
+ have never been called.
+
+ Args:
+ ad: Device on which to run.
+ limited_cb: Dictionary of CB_EV_* ids and maximum permitted calls (0
+ meaning never).
+ """
+ cb_data = json.loads(ad.adb.shell('cmd wifiaware native_cb get_cb_count'))
+
+ if limited_cb is None:
+ limited_cb = {}
+ # add callbacks which should never be called
+ limited_cb[aconsts.CB_EV_MATCH_EXPIRED] = 0
+
+ fail = False
+ for cb_event in limited_cb.keys():
+ if cb_event in cb_data:
+ if cb_data[cb_event] > limited_cb[cb_event]:
+ fail = True
+ ad.log.info(
+ 'Callback %s observed %d times: more then permitted %d times',
+ cb_event, cb_data[cb_event], limited_cb[cb_event])
+
+ asserts.assert_false(fail, 'Forbidden callbacks observed', extras=cb_data)
+
+def extract_stats(ad, data, results, key_prefix, log_prefix):
+ """Extract statistics from the data, store in the results dictionary, and
+ output to the info log.
+
+ Args:
+ ad: Android device (for logging)
+ data: A list containing the data to be analyzed.
+ results: A dictionary into which to place the statistics.
+ key_prefix: A string prefix to use for the dict keys storing the
+ extracted stats.
+ log_prefix: A string prefix to use for the info log.
+ include_data: If True includes the raw data in the dictionary,
+ otherwise just the stats.
+ """
+ num_samples = len(data)
+ results['%snum_samples' % key_prefix] = num_samples
+
+ if not data:
+ return
+
+ data_min = min(data)
+ data_max = max(data)
+ data_mean = statistics.mean(data)
+
+ results['%smin' % key_prefix] = data_min
+ results['%smax' % key_prefix] = data_max
+ results['%smean' % key_prefix] = data_mean
+ results['%sraw_data' % key_prefix] = data
+
+ if num_samples > 1:
+ data_stdev = statistics.stdev(data)
+ results['%sstdev' % key_prefix] = data_stdev
+ ad.log.info('%s: num_samples=%d, min=%.2f, max=%.2f, mean=%.2f, stdev=%.2f',
+ log_prefix, num_samples, data_min, data_max, data_mean,
+ data_stdev)
+ else:
+ ad.log.info('%s: num_samples=%d, min=%.2f, max=%.2f, mean=%.2f', log_prefix,
+ num_samples, data_min, data_max, data_mean)
+
+def get_mac_addr(device, interface):
+ """Get the MAC address of the specified interface. Uses ifconfig and parses
+ its output. Normalizes string to remove ':' and upper case.
+
+ Args:
+ device: Device on which to query the interface MAC address.
+ interface: Name of the interface for which to obtain the MAC address.
+ """
+ out = device.adb.shell("ifconfig %s" % interface)
+ res = re.match(".* HWaddr (\S+).*", out , re.S)
+ asserts.assert_true(
+ res,
+ 'Unable to obtain MAC address for interface %s' % interface,
+ extras=out)
+ return res.group(1).upper().replace(':', '')
+
+#########################################################
+# Aware primitives
+#########################################################
+
+def request_network(dut, ns):
+ """Request a Wi-Fi Aware network.
+
+ Args:
+ dut: Device
+ ns: Network specifier
+ Returns: the request key
+ """
+ network_req = {"TransportType": 5, "NetworkSpecifier": ns}
+ return dut.droid.connectivityRequestWifiAwareNetwork(network_req)
+
+def configure_dw(device, is_default, is_24_band, value):
+ """Use the command-line API to configure the DW (discovery window) setting
+
+ Args:
+ device: Device on which to perform configuration
+ is_default: True for the default setting, False for the non-interactive
+ setting
+ is_24_band: True for 2.4GHz band, False for 5GHz band
+ value: An integer 0 to 5
+ """
+ variable = 'dw_%s_%sghz' % ('default' if is_default else 'on_inactive', '24'
+ if is_24_band else '5')
+ device.adb.shell("cmd wifiaware native_api set %s %d" % (variable, value))
+
+def config_dw_high_power(device):
+ """Configure device's discovery window (DW) values to high power mode -
+ whether device is in interactive or non-interactive modes"""
+ configure_dw(
+ device, is_default=True, is_24_band=True, value=aconsts.DW_24_INTERACTIVE)
+ configure_dw(
+ device, is_default=True, is_24_band=False, value=aconsts.DW_5_INTERACTIVE)
+ configure_dw(
+ device,
+ is_default=False,
+ is_24_band=True,
+ value=aconsts.DW_24_INTERACTIVE)
+ configure_dw(
+ device,
+ is_default=False,
+ is_24_band=False,
+ value=aconsts.DW_5_INTERACTIVE)
+
+def config_dw_low_power(device):
+ """Configure device's discovery window (DW) values to low power mode - whether
+ device is in interactive or non-interactive modes"""
+ configure_dw(
+ device,
+ is_default=True,
+ is_24_band=True,
+ value=aconsts.DW_24_NON_INTERACTIVE)
+ configure_dw(
+ device,
+ is_default=True,
+ is_24_band=False,
+ value=aconsts.DW_5_NON_INTERACTIVE)
+ configure_dw(
+ device,
+ is_default=False,
+ is_24_band=True,
+ value=aconsts.DW_24_NON_INTERACTIVE)
+ configure_dw(
+ device,
+ is_default=False,
+ is_24_band=False,
+ value=aconsts.DW_5_NON_INTERACTIVE)
+
+def config_dw_all_modes(device, dw_24ghz, dw_5ghz):
+ """Configure device's discovery window (DW) values to the specified values -
+ whether the device is in interactive or non-interactive mode.
+
+ Args:
+ dw_24ghz: DW interval in the 2.4GHz band.
+ dw_5ghz: DW interval in the 5GHz band.
+ """
+ configure_dw(device, is_default=True, is_24_band=True, value=dw_24ghz)
+ configure_dw(device, is_default=True, is_24_band=False, value=dw_5ghz)
+ configure_dw(device, is_default=False, is_24_band=True, value=dw_24ghz)
+ configure_dw(device, is_default=False, is_24_band=False, value=dw_5ghz)
+
+def create_discovery_config(service_name,
+ d_type,
+ ssi=None,
+ match_filter=None,
+ match_filter_list=None,
+ ttl=0,
+ term_cb_enable=True):
+ """Create a publish discovery configuration based on input parameters.
+
+ Args:
+ service_name: Service name - required
+ d_type: Discovery type (publish or subscribe constants)
+ ssi: Supplemental information - defaults to None
+ match_filter, match_filter_list: The match_filter, only one mechanism can
+ be used to specify. Defaults to None.
+ ttl: Time-to-live - defaults to 0 (i.e. non-self terminating)
+ term_cb_enable: True (default) to enable callback on termination, False
+ means that no callback is called when session terminates.
+ Returns:
+ publish discovery configuration object.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = service_name
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = d_type
+ if ssi is not None:
+ config[aconsts.DISCOVERY_KEY_SSI] = ssi
+ if match_filter is not None:
+ config[aconsts.DISCOVERY_KEY_MATCH_FILTER] = match_filter
+ if match_filter_list is not None:
+ config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = match_filter_list
+ config[aconsts.DISCOVERY_KEY_TTL] = ttl
+ config[aconsts.DISCOVERY_KEY_TERM_CB_ENABLED] = term_cb_enable
+ return config
+
+def create_discovery_pair(p_dut,
+ s_dut,
+ p_config,
+ s_config,
+ device_startup_offset,
+ msg_id=None):
+ """Creates a discovery session (publish and subscribe), and waits for
+ service discovery - at that point the sessions are connected and ready for
+ further messaging of data-path setup.
+
+ Args:
+ p_dut: Device to use as publisher.
+ s_dut: Device to use as subscriber.
+ p_config: Publish configuration.
+ s_config: Subscribe configuration.
+ device_startup_offset: Number of seconds to offset the enabling of NAN on
+ the two devices.
+ msg_id: Controls whether a message is sent from Subscriber to Publisher
+ (so that publisher has the sub's peer ID). If None then not sent,
+ otherwise should be an int for the message id.
+ Returns: variable size list of:
+ p_id: Publisher attach session id
+ s_id: Subscriber attach session id
+ p_disc_id: Publisher discovery session id
+ s_disc_id: Subscriber discovery session id
+ peer_id_on_sub: Peer ID of the Publisher as seen on the Subscriber
+ peer_id_on_pub: Peer ID of the Subscriber as seen on the Publisher. Only
+ included if |msg_id| is not None.
+ """
+ p_dut.pretty_name = 'Publisher'
+ s_dut.pretty_name = 'Subscriber'
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach()
+ wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach()
+ wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Publisher: start publish and wait for confirmation
+ p_disc_id = p_dut.droid.wifiAwarePublish(p_id, p_config)
+ wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_disc_id = s_dut.droid.wifiAwareSubscribe(s_id, s_config)
+ wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
+
+ # Subscriber: wait for service discovery
+ discovery_event = wait_for_event(s_dut,
+ aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+ peer_id_on_sub = discovery_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ # Optionally send a message from Subscriber to Publisher
+ if msg_id is not None:
+ ping_msg = 'PING'
+
+ # Subscriber: send message to peer (Publisher)
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, msg_id,
+ ping_msg, aconsts.MAX_TX_RETRIES)
+ sub_tx_msg_event = wait_for_event(s_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
+ asserts.assert_equal(
+ msg_id, sub_tx_msg_event['data'][aconsts.SESSION_CB_KEY_MESSAGE_ID],
+ 'Subscriber -> Publisher message ID corrupted')
+
+ # Publisher: wait for received message
+ pub_rx_msg_event = wait_for_event(p_dut,
+ aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ peer_id_on_pub = pub_rx_msg_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
+ asserts.assert_equal(
+ ping_msg,
+ pub_rx_msg_event['data'][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING],
+ 'Subscriber -> Publisher message corrupted')
+ return p_id, s_id, p_disc_id, s_disc_id, peer_id_on_sub, peer_id_on_pub
+
+ return p_id, s_id, p_disc_id, s_disc_id, peer_id_on_sub
+
+def create_ib_ndp(p_dut, s_dut, p_config, s_config, device_startup_offset):
+ """Create an NDP (using in-band discovery)
+
+ Args:
+ p_dut: Device to use as publisher.
+ s_dut: Device to use as subscriber.
+ p_config: Publish configuration.
+ s_config: Subscribe configuration.
+ device_startup_offset: Number of seconds to offset the enabling of NAN on
+ the two devices.
+ """
+ (p_id, s_id, p_disc_id, s_disc_id, peer_id_on_sub,
+ peer_id_on_pub) = create_discovery_pair(
+ p_dut, s_dut, p_config, s_config, device_startup_offset, msg_id=9999)
+
+ # Publisher: request network
+ p_req_key = request_network(p_dut,
+ p_dut.droid.wifiAwareCreateNetworkSpecifier(
+ p_disc_id, peer_id_on_pub, None))
+
+ # Subscriber: request network
+ s_req_key = request_network(s_dut,
+ s_dut.droid.wifiAwareCreateNetworkSpecifier(
+ s_disc_id, peer_id_on_sub, None))
+
+ # Publisher & Subscriber: wait for network formation
+ p_net_event = wait_for_event_with_keys(
+ p_dut, cconsts.EVENT_NETWORK_CALLBACK, EVENT_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID,
+ p_req_key))
+ s_net_event = wait_for_event_with_keys(
+ s_dut, cconsts.EVENT_NETWORK_CALLBACK, EVENT_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID,
+ s_req_key))
+
+ p_aware_if = p_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ s_aware_if = s_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+
+ p_ipv6 = p_dut.droid.connectivityGetLinkLocalIpv6Address(p_aware_if).split(
+ "%")[0]
+ s_ipv6 = s_dut.droid.connectivityGetLinkLocalIpv6Address(s_aware_if).split(
+ "%")[0]
+
+ return p_req_key, s_req_key, p_aware_if, s_aware_if, p_ipv6, s_ipv6
+
+def create_oob_ndp_on_sessions(init_dut, resp_dut, init_id, init_mac, resp_id,
+ resp_mac):
+ """Create an NDP on top of existing Aware sessions (using OOB discovery)
+
+ Args:
+ init_dut: Initiator device
+ resp_dut: Responder device
+ init_id: Initiator attach session id
+ init_mac: Initiator discovery MAC address
+ resp_id: Responder attach session id
+ resp_mac: Responder discovery MAC address
+ Returns:
+ init_req_key: Initiator network request
+ resp_req_key: Responder network request
+ init_aware_if: Initiator Aware data interface
+ resp_aware_if: Responder Aware data interface
+ init_ipv6: Initiator IPv6 address
+ resp_ipv6: Responder IPv6 address
+ """
+ # Responder: request network
+ resp_req_key = request_network(
+ resp_dut,
+ resp_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None))
+
+ # Initiator: request network
+ init_req_key = request_network(
+ init_dut,
+ init_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None))
+
+ # Initiator & Responder: wait for network formation
+ init_net_event = wait_for_event_with_keys(
+ init_dut, cconsts.EVENT_NETWORK_CALLBACK, EVENT_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID,
+ init_req_key))
+ resp_net_event = wait_for_event_with_keys(
+ resp_dut, cconsts.EVENT_NETWORK_CALLBACK, EVENT_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED), (cconsts.NETWORK_CB_KEY_ID,
+ resp_req_key))
+
+ init_aware_if = init_net_event['data'][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ resp_aware_if = resp_net_event['data'][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+
+ init_ipv6 = init_dut.droid.connectivityGetLinkLocalIpv6Address(
+ init_aware_if).split('%')[0]
+ resp_ipv6 = resp_dut.droid.connectivityGetLinkLocalIpv6Address(
+ resp_aware_if).split('%')[0]
+
+ return (init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
+ resp_ipv6)
+
+def create_oob_ndp(init_dut, resp_dut):
+ """Create an NDP (using OOB discovery)
+
+ Args:
+ init_dut: Initiator device
+ resp_dut: Responder device
+ """
+ init_dut.pretty_name = 'Initiator'
+ resp_dut.pretty_name = 'Responder'
+
+ # Initiator+Responder: attach and wait for confirmation & identity
+ init_id = init_dut.droid.wifiAwareAttach(True)
+ wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ init_ident_event = wait_for_event(init_dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ init_mac = init_ident_event['data']['mac']
+ resp_id = resp_dut.droid.wifiAwareAttach(True)
+ wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ resp_ident_event = wait_for_event(resp_dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ resp_mac = resp_ident_event['data']['mac']
+
+ # wait for for devices to synchronize with each other - there are no other
+ # mechanisms to make sure this happens for OOB discovery (except retrying
+ # to execute the data-path request)
+ time.sleep(WAIT_FOR_CLUSTER)
+
+ (init_req_key, resp_req_key, init_aware_if,
+ resp_aware_if, init_ipv6, resp_ipv6) = create_oob_ndp_on_sessions(
+ init_dut, resp_dut, init_id, init_mac, resp_id, resp_mac)
+
+ return (init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
+ resp_ipv6)
diff --git a/acts/framework/acts/utils.py b/acts/framework/acts/utils.py
index b23fdb0..802e0c1 100755
--- a/acts/framework/acts/utils.py
+++ b/acts/framework/acts/utils.py
@@ -30,6 +30,8 @@
import traceback
import zipfile
+from acts.controllers import adb
+
# File name length is limited to 255 chars on some OS, so we need to make sure
# the file names we output fits within the limit.
MAX_FILENAME_LEN = 255
@@ -723,28 +725,62 @@
1 if new_state else 0))
-def bypass_setup_wizard(ad):
+def bypass_setup_wizard(ad, bypass_wait_time=3):
"""Bypass the setup wizard on an input Android device
Args:
ad: android device object.
+ bypass_wait_time: Do not set this variable. Only modified for framework
+ tests.
Returns:
True if Andorid device successfully bypassed the setup wizard.
False if failed.
"""
- ad.adb.shell(
- "am start -n \"com.google.android.setupwizard/.SetupWizardExitActivity\""
- )
+ try:
+ ad.adb.shell("am start -n \"com.google.android.setupwizard/"
+ ".SetupWizardExitActivity\"")
+ logging.debug("No error during default bypass call.")
+ except adb.AdbError as adb_error:
+ if adb_error.stdout == "ADB_CMD_OUTPUT:0":
+ if adb_error.stderr and \
+ not adb_error.stderr.startswith("Error type 3\n"):
+ logging.error(
+ "ADB_CMD_OUTPUT:0, but error is %s " % adb_error.stderr)
+ raise adb_error
+ logging.debug("Bypass wizard call received harmless error 3: "
+ "No setup to bypass.")
+ elif adb_error.stdout == "ADB_CMD_OUTPUT:255":
+ # Run it again as root.
+ ad.adb.root_adb()
+ logging.debug("Need root access to bypass setup wizard.")
+ try:
+ ad.adb.shell("am start -n \"com.google.android.setupwizard/"
+ ".SetupWizardExitActivity\"")
+ logging.debug("No error during rooted bypass call.")
+ except adb.AdbError as adb_error:
+ if adb_error.stdout == "ADB_CMD_OUTPUT:0":
+ if adb_error.stderr and \
+ not adb_error.stderr.startswith("Error type 3\n"):
+ logging.error("Rooted ADB_CMD_OUTPUT:0, but error is "
+ "%s " % adb_error.stderr)
+ raise adb_error
+ logging.debug(
+ "Rooted bypass wizard call received harmless "
+ "error 3: No setup to bypass.")
+
# magical sleep to wait for the gservices override broadcast to complete
- time.sleep(3)
+ time.sleep(bypass_wait_time)
+
provisioned_state = int(
ad.adb.shell("settings get global device_provisioned"))
- if (provisioned_state != 1):
+ if provisioned_state != 1:
logging.error("Failed to bypass setup wizard.")
return False
+ logging.debug("Setup wizard successfully bypassed.")
return True
+
def parse_ping_ouput(ad, count, out, loss_tolerance=20):
"""Ping Parsing util.
@@ -780,7 +816,10 @@
return True
-def adb_shell_ping(ad, count=120, dest_ip="www.google.com", timeout=200,
+def adb_shell_ping(ad,
+ count=120,
+ dest_ip="www.google.com",
+ timeout=200,
loss_tolerance=20):
"""Ping utility using adb shell.
diff --git a/acts/framework/setup.py b/acts/framework/setup.py
index ed550e7..48c71bb 100755
--- a/acts/framework/setup.py
+++ b/acts/framework/setup.py
@@ -24,7 +24,8 @@
import sys
install_requires = [
- 'future',
+ # Future needs to have a newer version that contains urllib.
+ 'future>=0.16.0',
# mock-1.0.1 is the last version compatible with setuptools <17.1,
# which is what comes with Ubuntu 14.04 LTS.
'mock<=1.0.1',
@@ -78,6 +79,8 @@
pass
def run(self):
+ import pip
+ pip.main(['install', '--upgrade', 'pip'])
required_packages = self.distribution.install_requires
for package in required_packages:
diff --git a/acts/framework/tests/acts_adb_test.py b/acts/framework/tests/acts_adb_test.py
new file mode 100755
index 0000000..b56ef8b
--- /dev/null
+++ b/acts/framework/tests/acts_adb_test.py
@@ -0,0 +1,72 @@
+#!/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 unittest
+import mock
+from acts.controllers import adb
+
+
+class MockJob(object):
+ def __init__(self, exit_status=0, stderr='', stdout=''):
+ self.exit_status = exit_status
+ self.stderr = stderr
+ self.stdout = stdout
+
+
+class MockAdbProxy(adb.AdbProxy):
+ def __init__(self):
+ pass
+
+
+class ADBTest(unittest.TestCase):
+ """A class for testing acts/controllers/adb.py"""
+
+ def test__exec_cmd_failure_old_adb(self):
+ mock_job = MockJob(exit_status=1, stderr='error: device not found')
+ cmd = ['adb', '-s', '"SOME_SERIAL"', 'shell', '"SOME_SHELL_CMD"']
+ with mock.patch('acts.libs.proc.job.run', return_value=mock_job):
+ with self.assertRaises(adb.AdbError):
+ MockAdbProxy()._exec_cmd(cmd)
+
+ def test__exec_cmd_failure_new_adb(self):
+ mock_job = MockJob(
+ exit_status=1, stderr='error: device \'DEADBEEF\' not found')
+ cmd = ['adb', '-s', '"SOME_SERIAL"', 'shell', '"SOME_SHELL_CMD"']
+ with mock.patch('acts.libs.proc.job.run', return_value=mock_job):
+ with self.assertRaises(adb.AdbError):
+ MockAdbProxy()._exec_cmd(cmd)
+
+ def test__exec_cmd_pass_ret_1(self):
+ mock_job = MockJob(exit_status=1, stderr='error not related to adb')
+ cmd = ['adb', '-s', '"SOME_SERIAL"', 'shell', '"SOME_SHELL_CMD"']
+ with mock.patch('acts.libs.proc.job.run', return_value=mock_job):
+ MockAdbProxy()._exec_cmd(cmd)
+
+ def test__exec_cmd_pass_basic(self):
+ mock_job = MockJob(exit_status=0, stderr='', stdout='FEEDACAB')
+ cmd = ['adb', '-s', '"SOME_SERIAL"', 'shell', '"SOME_SHELL_CMD"']
+ with mock.patch('acts.libs.proc.job.run', return_value=mock_job):
+ MockAdbProxy()._exec_cmd(cmd)
+
+ def test__exec_cmd_pass_no_stdout(self):
+ mock_job = MockJob(exit_status=0, stderr='', stdout='')
+ cmd = ['adb', '-s', '"SOME_SERIAL"', 'shell', '"SOME_SHELL_CMD"']
+ with mock.patch('acts.libs.proc.job.run', return_value=mock_job):
+ MockAdbProxy()._exec_cmd(cmd)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/acts/framework/tests/acts_base_class_test.py b/acts/framework/tests/acts_base_class_test.py
index 53849ed..75bd2e2 100755
--- a/acts/framework/tests/acts_base_class_test.py
+++ b/acts/framework/tests/acts_base_class_test.py
@@ -956,9 +956,10 @@
return "test_%s_%s" % (setting, arg)
def logic(self, setting, arg, special_arg=None):
- asserts.assert_true(setting in itrs, (
- "%s is not in acceptable settings range %s") %
- (setting, itrs))
+ asserts.assert_true(
+ setting in itrs,
+ ("%s is not in acceptable settings range %s") % (setting,
+ itrs))
asserts.assert_true(arg == static_arg,
"Expected %s, got %s" % (static_arg, arg))
asserts.assert_true(arg == static_arg, "Expected %s, got %s" %
diff --git a/acts/framework/tests/acts_relay_controller_test.py b/acts/framework/tests/acts_relay_controller_test.py
index bb06eb6..2676bff 100755
--- a/acts/framework/tests/acts_relay_controller_test.py
+++ b/acts/framework/tests/acts_relay_controller_test.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3.4
#
# Copyright 2016 - The Android Open Source Project
#
@@ -20,19 +20,27 @@
import shutil
import unittest
-from acts.controllers.relay_lib.generic_relay_device import GenericRelayDevice
-from acts.controllers.relay_lib.relay import Relay
-from acts.controllers.relay_lib.relay import RelayDict
-from acts.controllers.relay_lib.relay import RelayState
-from acts.controllers.relay_lib.relay import SynchronizeRelays
-from acts.controllers.relay_lib.relay_board import RelayBoard
-from acts.controllers.relay_lib.relay_device import RelayDevice
-from acts.controllers.relay_lib.relay_rig import RelayRig
-from acts.controllers.relay_lib.sain_smart_board import SainSmartBoard
+from acts.controllers.relay_lib import generic_relay_device
+from acts.controllers.relay_lib import relay
+from acts.controllers.relay_lib import relay_board
+from acts.controllers.relay_lib import relay_device
+from acts.controllers.relay_lib import relay_rig
+from acts.controllers.relay_lib import sain_smart_board
import acts.controllers.relay_lib.errors as errors
import acts.controllers.relay_lib.fugu_remote as fugu_remote
+# Shorthand versions of the long class names.
+GenericRelayDevice = generic_relay_device.GenericRelayDevice
+Relay = relay.Relay
+RelayDict = relay.RelayDict
+RelayState = relay.RelayState
+SynchronizeRelays = relay.SynchronizeRelays
+RelayBoard = relay_board.RelayBoard
+RelayDevice = relay_device.RelayDevice
+RelayRig = relay_rig.RelayRig
+SainSmartBoard = sain_smart_board.SainSmartBoard
+
class MockBoard(RelayBoard):
def __init__(self, config):
@@ -366,26 +374,25 @@
def test_init_relay_rig_device_gets_relays(self):
modded_config = copy.deepcopy(self.config)
del modded_config['devices'][0]['relays']['Relay00']
- relay_rig = RelayRigMock(modded_config)
- self.assertEqual(len(relay_rig.relays), 4)
- self.assertEqual(len(relay_rig.devices['device'].relays), 1)
+ rig = RelayRigMock(modded_config)
+ self.assertEqual(len(rig.relays), 4)
+ self.assertEqual(len(rig.devices['device'].relays), 1)
- relay_rig = RelayRigMock(self.config)
- self.assertEqual(len(relay_rig.devices['device'].relays), 2)
+ rig = RelayRigMock(self.config)
+ self.assertEqual(len(rig.devices['device'].relays), 2)
def test_init_relay_rig_correct_device_type(self):
- relay_rig = RelayRigMock(self.config)
- self.assertEqual(len(relay_rig.devices), 1)
- self.assertIsInstance(relay_rig.devices['device'], GenericRelayDevice)
+ rig = RelayRigMock(self.config)
+ self.assertEqual(len(rig.devices), 1)
+ self.assertIsInstance(rig.devices['device'], GenericRelayDevice)
def test_init_relay_rig_missing_devices_creates_generic_device(self):
modded_config = copy.deepcopy(self.config)
del modded_config['devices']
- relay_rig = RelayRigMock(modded_config)
- self.assertEqual(len(relay_rig.devices), 1)
- self.assertIsInstance(relay_rig.devices['device'], GenericRelayDevice)
- self.assertDictEqual(relay_rig.devices['device'].relays,
- relay_rig.relays)
+ rig = RelayRigMock(modded_config)
+ self.assertEqual(len(rig.devices), 1)
+ self.assertIsInstance(rig.devices['device'], GenericRelayDevice)
+ self.assertDictEqual(rig.devices['device'].relays, rig.relays)
class RelayRigMock(RelayRig):
@@ -445,8 +452,8 @@
modified_config = copy.deepcopy(self.device_config)
del modified_config['relays']['r1']
- generic_relay_device = GenericRelayDevice(modified_config, self.rig)
- generic_relay_device.setup()
+ grd = GenericRelayDevice(modified_config, self.rig)
+ grd.setup()
self.assertEqual(self.r0.get_status(), RelayState.NO)
self.assertEqual(self.r1.get_status(), RelayState.NC)
@@ -455,8 +462,8 @@
self.board.set(self.r0.position, RelayState.NC)
self.board.set(self.r1.position, RelayState.NC)
- generic_relay_device = GenericRelayDevice(self.device_config, self.rig)
- generic_relay_device.setup()
+ grd = GenericRelayDevice(self.device_config, self.rig)
+ grd.setup()
self.assertEqual(self.r0.get_status(), RelayState.NO)
self.assertEqual(self.r1.get_status(), RelayState.NO)
@@ -469,8 +476,8 @@
def change_state(self, begin_state, call, end_state, previous_state=None):
self.board.set(self.r0.position, begin_state)
- generic_relay_device = GenericRelayDevice(self.device_config, self.rig)
- call(generic_relay_device)
+ grd = GenericRelayDevice(self.device_config, self.rig)
+ call(grd)
self.assertEqual(self.r0.get_status(), end_state)
if previous_state:
self.assertEqual(
@@ -632,8 +639,8 @@
'r1': 'MockBoard/1'
}
}
- relay_device = rig.create_relay_device(config)
- self.assertIsInstance(relay_device, GenericRelayDevice)
+ device = rig.create_relay_device(config)
+ self.assertIsInstance(device, GenericRelayDevice)
def test_create_relay_device_config_with_type(self):
rig = RelayRigMock()
@@ -647,8 +654,8 @@
'r1': 'MockBoard/1'
}
}
- relay_device = rig.create_relay_device(config)
- self.assertIsInstance(relay_device, GenericRelayDevice)
+ device = rig.create_relay_device(config)
+ self.assertIsInstance(device, GenericRelayDevice)
def test_create_relay_device_raise_on_type_not_found(self):
rig = RelayRigMock()
diff --git a/acts/framework/tests/acts_utils_test.py b/acts/framework/tests/acts_utils_test.py
index 7ee2c9d..fd7b083 100755
--- a/acts/framework/tests/acts_utils_test.py
+++ b/acts/framework/tests/acts_utils_test.py
@@ -16,8 +16,10 @@
import time
import unittest
+import enum
from acts import utils
+from acts.controllers.adb import AdbError
class ActsUtilsTest(unittest.TestCase):
@@ -37,6 +39,97 @@
"Process .* has terminated"):
utils.stop_standing_subprocess(p)
+ def test_bypass_setup_wizard_no_complications(self):
+ ad = MockAd()
+ ad.adb.return_state = BypassSetupWizardReturn.NO_COMPLICATIONS
+ self.assertTrue(utils.bypass_setup_wizard(ad, 0))
+ self.assertFalse(ad.adb.root_adb_called)
+
+ def test_bypass_setup_wizard_unrecognized_error(self):
+ ad = MockAd()
+ ad.adb.return_state = BypassSetupWizardReturn.UNRECOGNIZED_ERR
+ with self.assertRaises(AdbError):
+ utils.bypass_setup_wizard(ad, 0)
+ self.assertFalse(ad.adb.root_adb_called)
+
+ def test_bypass_setup_wizard_need_root_access(self):
+ ad = MockAd()
+ ad.adb.return_state = BypassSetupWizardReturn.ROOT_ADB_NO_COMP
+ self.assertTrue(utils.bypass_setup_wizard(ad, 0))
+ self.assertTrue(ad.adb.root_adb_called)
+
+ def test_bypass_setup_wizard_need_root_already_skipped(self):
+ ad = MockAd()
+ ad.adb.return_state = BypassSetupWizardReturn.ROOT_ADB_SKIPPED
+ self.assertTrue(utils.bypass_setup_wizard(ad, 0))
+ self.assertTrue(ad.adb.root_adb_called)
+
+ def test_bypass_setup_wizard_root_access_still_fails(self):
+ ad = MockAd()
+ ad.adb.return_state = BypassSetupWizardReturn.ROOT_ADB_FAILS
+ with self.assertRaises(AdbError):
+ utils.bypass_setup_wizard(ad, 0)
+ self.assertTrue(ad.adb.root_adb_called)
+
+
+class BypassSetupWizardReturn:
+ # No complications. Bypass works the first time without issues.
+ NO_COMPLICATIONS = AdbError("", "", "", 1)
+ # Fail with doesn't need to be skipped/was skipped already.
+ ALREADY_BYPASSED = AdbError("", "ADB_CMD_OUTPUT:0", "Error type 3\n"
+ "Error: Activity class", 1)
+ # Fail with different error.
+ UNRECOGNIZED_ERR = AdbError("", "ADB_CMD_OUTPUT:0", "Error type 4\n"
+ "Error: Activity class", 0)
+ # Fail, get root access, then no complications arise.
+ ROOT_ADB_NO_COMP = AdbError("", "ADB_CMD_OUTPUT:255",
+ "Security exception: Permission Denial: "
+ "starting Intent { flg=0x10000000 "
+ "cmp=com.google.android.setupwizard/"
+ ".SetupWizardExitActivity } from null "
+ "(pid=5045, uid=2000) not exported from uid "
+ "10000", 0)
+ # Even with root access, the bypass setup wizard doesn't need to be skipped.
+ ROOT_ADB_SKIPPED = AdbError("", "ADB_CMD_OUTPUT:255",
+ "Security exception: Permission Denial: "
+ "starting Intent { flg=0x10000000 "
+ "cmp=com.google.android.setupwizard/"
+ ".SetupWizardExitActivity } from null "
+ "(pid=5045, uid=2000) not exported from "
+ "uid 10000", 0)
+ # Even with root access, the bypass setup wizard fails
+ ROOT_ADB_FAILS = AdbError(
+ "", "ADB_CMD_OUTPUT:255", "Security exception: Permission Denial: "
+ "starting Intent { flg=0x10000000 "
+ "cmp=com.google.android.setupwizard/"
+ ".SetupWizardExitActivity } from null (pid=5045, "
+ "uid=2000) not exported from uid 10000", 0)
+
+
+class MockAd:
+ def __init__(self):
+ self.adb = MockAdb()
+
+
+class MockAdb:
+ def __init__(self):
+ self.return_state = BypassSetupWizardReturn.NO_COMPLICATIONS
+ self.root_adb_called = False
+
+ def shell(self, string):
+ if string == "settings get global device_provisioned":
+ return self.return_state.ret_code
+ raise self.return_state
+
+ def root_adb(self):
+ self.root_adb_called = True
+ if self.return_state is BypassSetupWizardReturn.ROOT_ADB_FAILS:
+ self.return_state = BypassSetupWizardReturn.UNRECOGNIZED_ERR
+ elif self.return_state is not BypassSetupWizardReturn.ROOT_ADB_SKIPPED:
+ self.return_state = BypassSetupWizardReturn.ALREADY_BYPASSED
+ else:
+ self.return_state = BypassSetupWizardReturn.NO_COMPLICATIONS
+
if __name__ == "__main__":
unittest.main()
diff --git a/acts/tests/google/ble/gatt/GattConnectTest.py b/acts/tests/google/ble/gatt/GattConnectTest.py
index 374becd..667611d 100644
--- a/acts/tests/google/ble/gatt/GattConnectTest.py
+++ b/acts/tests/google/ble/gatt/GattConnectTest.py
@@ -34,13 +34,14 @@
from acts.test_utils.bt.bt_constants import gatt_transport
from acts.test_utils.bt.bt_gatt_utils import GattTestUtilsError
from acts.test_utils.bt.bt_gatt_utils import disconnect_gatt_connection
+from acts.test_utils.bt.bt_gatt_utils import wait_for_gatt_disconnect_event
+from acts.test_utils.bt.bt_gatt_utils import close_gatt_client
from acts.test_utils.bt.bt_gatt_utils import log_gatt_server_uuids
from acts.test_utils.bt.bt_gatt_utils import orchestrate_gatt_connection
-from acts.test_utils.bt.bt_gatt_utils import setup_gatt_characteristics
from acts.test_utils.bt.bt_gatt_utils import setup_gatt_connection
-from acts.test_utils.bt.bt_gatt_utils import setup_gatt_descriptors
from acts.test_utils.bt.bt_gatt_utils import setup_multiple_services
from acts.test_utils.bt.bt_test_utils import get_mac_address_of_generic_advertisement
+from acts.test_utils.bt.bt_test_utils import clear_bonded_devices
class GattConnectTest(BluetoothBaseTest):
@@ -75,6 +76,7 @@
try:
disconnect_gatt_connection(self.cen_ad, bluetooth_gatt,
gatt_callback)
+ close_gatt_client(self.cen_ad, bluetooth_gatt)
if bluetooth_gatt in self.bluetooth_gatt_list:
self.bluetooth_gatt_list.remove(bluetooth_gatt)
except GattTestUtilsError as err:
@@ -224,7 +226,7 @@
try:
self._orchestrate_gatt_disconnection(bluetooth_gatt, gatt_callback)
except Exception as err:
- self.log.info("Failed to orchestrate disconnect: {}".format(e))
+ self.log.info("Failed to orchestrate disconnect: {}".format(err))
return False
return True
@@ -233,7 +235,7 @@
def test_gatt_connect_autoconnect(self):
"""Test GATT connection over LE.
- Test re-establishing a gat connection using autoconnect
+ Test re-establishing a gatt connection using autoconnect
set to True in order to test connection whitelist.
Steps:
@@ -274,6 +276,7 @@
try:
disconnect_gatt_connection(self.cen_ad, bluetooth_gatt,
gatt_callback)
+ close_gatt_client(self.cen_ad, bluetooth_gatt)
if bluetooth_gatt in self.bluetooth_gatt_list:
self.bluetooth_gatt_list.remove(bluetooth_gatt)
except GattTestUtilsError as err:
@@ -281,9 +284,8 @@
return False
autoconnect = True
bluetooth_gatt = self.cen_ad.droid.gattClientConnectGatt(
- gatt_callback, mac_address, autoconnect,
- gatt_transport['auto'],
- gatt_phy_mask['1m_mask'])
+ gatt_callback, mac_address, autoconnect, gatt_transport['auto'],
+ False, gatt_phy_mask['1m_mask'])
self.bluetooth_gatt_list.append(bluetooth_gatt)
expected_event = gatt_cb_strings['gatt_conn_change'].format(
gatt_callback)
@@ -298,6 +300,82 @@
gatt_callback)
@BluetoothBaseTest.bt_test_wrap
+ @test_tracker_info(uuid='e506fa50-7cd9-4bd8-938a-6b85dcfe6bc6')
+ def test_gatt_connect_opportunistic(self):
+ """Test opportunistic GATT connection over LE.
+
+ Test establishing a gatt connection between a GATT server and GATT
+ client in opportunistic mode.
+
+ Steps:
+ 1. Start a generic advertisement.
+ 2. Start a generic scanner.
+ 3. Find the advertisement and extract the mac address.
+ 4. Stop the first scanner.
+ 5. Create GATT connection 1 between the scanner and advertiser normally
+ 6. Create GATT connection 2 between the scanner and advertiser using
+ opportunistic mode
+ 7. Disconnect GATT connection 1
+
+ Expected Result:
+ Verify GATT connection 2 automatically disconnects when GATT connection
+ 1 disconnect
+
+ Returns:
+ Pass if True
+ Fail if False
+
+ TAGS: LE, Advertising, Filtering, Scanning, GATT
+ Priority: 0
+ """
+ gatt_server_cb = self.per_ad.droid.gattServerCreateGattServerCallback()
+ gatt_server = self.per_ad.droid.gattServerOpenGattServer(
+ gatt_server_cb)
+ self.gatt_server_list.append(gatt_server)
+ mac_address, adv_callback = (
+ get_mac_address_of_generic_advertisement(self.cen_ad, self.per_ad))
+ # Make GATT connection 1
+ try:
+ bluetooth_gatt_1, gatt_callback_1 = setup_gatt_connection(
+ self.cen_ad,
+ mac_address,
+ False,
+ transport=gatt_transport['auto'],
+ opportunistic=False)
+ self.bluetooth_gatt_list.append(bluetooth_gatt_1)
+ except GattTestUtilsError as err:
+ self.log.error(err)
+ return False
+ # Make GATT connection 2
+ try:
+ bluetooth_gatt_2, gatt_callback_2 = setup_gatt_connection(
+ self.cen_ad,
+ mac_address,
+ False,
+ transport=gatt_transport['auto'],
+ opportunistic=True)
+ self.bluetooth_gatt_list.append(bluetooth_gatt_2)
+ except GattTestUtilsError as err:
+ self.log.error(err)
+ return False
+ # Disconnect GATT connection 1
+ try:
+ disconnect_gatt_connection(self.cen_ad, bluetooth_gatt_1,
+ gatt_callback_1)
+ close_gatt_client(self.cen_ad, bluetooth_gatt_1)
+ if bluetooth_gatt_1 in self.bluetooth_gatt_list:
+ self.bluetooth_gatt_list.remove(bluetooth_gatt_1)
+ except GattTestUtilsError as err:
+ self.log.error(err)
+ return False
+ # Confirm that GATT connection 2 also disconnects
+ wait_for_gatt_disconnect_event(self.cen_ad, gatt_callback_2)
+ close_gatt_client(self.cen_ad, bluetooth_gatt_2)
+ if bluetooth_gatt_2 in self.bluetooth_gatt_list:
+ self.bluetooth_gatt_list.remove(bluetooth_gatt_2)
+ return True
+
+ @BluetoothBaseTest.bt_test_wrap
@test_tracker_info(uuid='1e01838e-c4de-4720-9adf-9e0419378226')
def test_gatt_request_min_mtu(self):
"""Test GATT connection over LE and exercise MTU sizes.
@@ -717,7 +795,6 @@
return False
test_result = self._orchestrate_gatt_disconnection(bluetooth_gatt,
gatt_callback)
- self.cen_ad.droid.gattClientClose(bluetooth_gatt)
if not test_result:
self.log.info("Failed to disconnect from peripheral device.")
return False
@@ -821,8 +898,18 @@
start_time = time.time() + self.default_timeout
target_name = self.per_ad.droid.bluetoothGetLocalName()
while time.time() < start_time and bonded == False:
- bonded_devices = self.cen_ad.droid.bluetoothGetBondedDevices(
- )
+ bonded_devices = \
+ self.cen_ad.droid.bluetoothGetBondedDevices()
+ for device in bonded_devices:
+ if ('name' in device.keys() and
+ device['name'] == target_name):
+ bonded = True
+ break
+ bonded = False
+ target_name = self.cen_ad.droid.bluetoothGetLocalName()
+ while time.time() < start_time and bonded == False:
+ bonded_devices = \
+ self.per_ad.droid.bluetoothGetBondedDevices()
for device in bonded_devices:
if ('name' in device.keys() and
device['name'] == target_name):
diff --git a/acts/tests/google/bt/pts/BtCmdLineTest.py b/acts/tests/google/bt/pts/BtCmdLineTest.py
index 2e81163..5091db3 100644
--- a/acts/tests/google/bt/pts/BtCmdLineTest.py
+++ b/acts/tests/google/bt/pts/BtCmdLineTest.py
@@ -40,8 +40,7 @@
self.log.error(
"Missing mandatory user config \"target_mac_address\"!")
return False
- self.target_mac_address = self.user_params["target_mac_address"].upper(
- )
+ self.target_mac_address = self.user_params["target_mac_address"].upper()
self.android_devices[0].droid.bluetoothSetLocalName("CMD LINE Test")
if len(self.android_devices) > 1:
@@ -78,8 +77,8 @@
for filename in filenames:
file = os.path.join(dirname, filename)
#TODO: Handle file paths with spaces
- self.android_devices[0].adb.push("{} {}".format(
- file, android_music_path))
+ self.android_devices[0].adb.push(
+ "{} {}".format(file, android_music_path))
def setup_class(self):
return True
diff --git a/acts/tests/google/bt/pts/cmd_input.py b/acts/tests/google/bt/pts/cmd_input.py
index e1579b2..e97b1a4 100644
--- a/acts/tests/google/bt/pts/cmd_input.py
+++ b/acts/tests/google/bt/pts/cmd_input.py
@@ -16,7 +16,6 @@
"""
Python script for wrappers to various libraries.
"""
-
from acts.test_utils.bt.BtEnum import BluetoothScanModeType
from acts.test_utils.bt.GattEnum import GattServerResponses
from ble_lib import BleLib
@@ -26,6 +25,7 @@
from gatts_lib import GattServerLib
from rfcomm_lib import RfcommLib
+import time
import cmd
import gatt_test_database
"""Various Global Strings"""
@@ -37,6 +37,30 @@
"""Simple command processor for Bluetooth PTS Testing"""
gattc_lib = None
+ def connect_hsp_helper(self, ad):
+ """A helper function for making HSP connections"""
+ end_time = time.time() + 20
+ connected_hsp_devices = len(ad.droid.bluetoothHspGetConnectedDevices())
+ while connected_hsp_devices != 1 and time.time() < end_time:
+ try:
+ ad.droid.bluetoothHspConnect(self.mac_addr)
+ time.sleep(3)
+ if len(ad.droid.bluetoothHspGetConnectedDevices() == 1):
+ break
+ except Exception:
+ self.log.debug("Failed to connect hsp trying again...")
+ try:
+ ad.droid.bluetoothConnectBonded(self.mac_addr)
+ except Exception:
+ self.log.info("Failed to connect to bonded device...")
+ connected_hsp_devices = len(
+ ad.droid.bluetoothHspGetConnectedDevices())
+ if connected_hsp_devices != 1:
+ self.log.error("Failed to reconnect to HSP service...")
+ return False
+ self.log.info("Connected to HSP service...")
+ return True
+
def setup_vars(self, android_devices, mac_addr, log):
self.pri_dut = android_devices[0]
if len(android_devices) > 1:
diff --git a/acts/tests/google/native/bt/BtNativeTest.py b/acts/tests/google/native/bt/BtNativeTest.py
index 9660a8e..5315e34 100644
--- a/acts/tests/google/native/bt/BtNativeTest.py
+++ b/acts/tests/google/native/bt/BtNativeTest.py
@@ -1,20 +1,4 @@
-#/usr/bin/env python3.4
-#
-# Copyright (C) 2016 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
+mport time
from acts.base_test import BaseTestClass
from acts.controllers import native_android_device
from acts.test_utils.bt.native_bt_test_utils import setup_native_bluetooth
@@ -26,14 +10,15 @@
def __init__(self, controllers):
BaseTestClass.__init__(self, controllers)
- setup_native_bluetooth(self.native_devices)
- self.droid = self.native_devices[0].droid
- self.tests = ("test_binder_get_name",
- "test_binder_get_name_invalid_parameter",
- "test_binder_set_name_get_name",
- "test_binder_get_address", )
- if len(self.native_devices) > 1:
- self.droid1 = self.native_devices[1].droid
+ setup_native_bluetooth(self.native_android_devices)
+ self.droid = self.native_android_devices[0].droid
+ self.tests = (
+ "test_binder_get_name",
+ "test_binder_get_name_invalid_parameter",
+ "test_binder_set_name_get_name",
+ "test_binder_get_address", )
+ if len(self.native_android_devices) > 1:
+ self.droid1 = self.native_android_devices[1].droid
self.tests = self.tests + ("test_two_devices_set_get_name", )
def test_binder_get_name(self):
@@ -67,10 +52,11 @@
def test_two_devices_set_get_name(self):
test_name = generate_id_by_size(4)
- for n in self.native_devices:
+ for n in self.native_android_devices:
d = n.droid
d.BtBinderSetName(test_name)
name = d.BtBinderGetName()
if name != test_name:
return False
return True
+
diff --git a/acts/tests/google/tel/live/TelLivePreflightTest.py b/acts/tests/google/tel/live/TelLivePreflightTest.py
index 2e0a78c..adb1379 100644
--- a/acts/tests/google/tel/live/TelLivePreflightTest.py
+++ b/acts/tests/google/tel/live/TelLivePreflightTest.py
@@ -19,6 +19,8 @@
import time
from queue import Empty
+
+from acts.test_decorators import test_tracker_info
from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
from acts.test_utils.tel.tel_defines import AOSP_PREFIX
from acts.test_utils.tel.tel_defines import CAPABILITY_PHONE
@@ -58,11 +60,9 @@
TelephonyBaseTest.__init__(self, controllers)
self.wifi_network_ssid = self.user_params.get(
- "wifi_network_ssid") or self.user_params.get(
- "wifi_network_ssid_2g")
+ "wifi_network_ssid") or self.user_params.get("wifi_network_ssid_2g")
self.wifi_network_pass = self.user_params.get(
- "wifi_network_pass") or self.user_params.get(
- "wifi_network_pass_2g")
+ "wifi_network_pass") or self.user_params.get("wifi_network_pass_2g")
def setup_class(self):
pass
@@ -72,6 +72,7 @@
""" Tests Begin """
+ @test_tracker_info(uuid="8390a2eb-a744-4cda-bade-f94a2cc83f02")
@TelephonyBaseTest.tel_test_wrap
def test_check_environment(self):
ad = self.android_devices[0]
@@ -91,6 +92,7 @@
# TODO: add more environment check here.
return True
+ @test_tracker_info(uuid="7bb23ac7-6b7b-4d5e-b8d6-9dd10032b9ad")
@TelephonyBaseTest.tel_test_wrap
def test_pre_flight_check(self):
for ad in self.android_devices:
@@ -99,6 +101,7 @@
abort_all_tests(ad.log, "Unable to find a valid subscription!")
return True
+ @test_tracker_info(uuid="1070b160-902b-43bf-92a0-92cc2d05bb13")
@TelephonyBaseTest.tel_test_wrap
def test_check_crash(self):
for ad in self.android_devices:
diff --git a/acts/tests/google/wifi/SetupWifiNetworkTest.py b/acts/tests/google/wifi/SetupWifiNetworkTest.py
new file mode 100644
index 0000000..26026ff
--- /dev/null
+++ b/acts/tests/google/wifi/SetupWifiNetworkTest.py
@@ -0,0 +1,107 @@
+#!/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 logging
+import socket
+import sys
+
+from acts import base_test
+from acts.controllers.ap_lib import hostapd_ap_preset
+from acts.controllers.ap_lib import hostapd_bss_settings
+from acts.controllers.ap_lib import hostapd_constants
+from acts.controllers.ap_lib import hostapd_config
+from acts.controllers.ap_lib import hostapd_security
+
+
+class SetupWifiNetworkTest(base_test.BaseTestClass):
+ def wait_for_test_completion(self):
+ port = int(self.user_params["socket_port"])
+ timeout = float(self.user_params["socket_timeout_secs"])
+
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+ server_address = ('localhost', port)
+ logging.info("Starting server socket on localhost port %s", port)
+ sock.bind(('localhost', port))
+ sock.settimeout(timeout)
+ sock.listen(1)
+ logging.info("Waiting for client socket connection")
+ try:
+ connection, client_address = sock.accept()
+ except socket.timeout:
+ logging.error("Did not receive signal. Shutting down AP")
+ except socket.error:
+ logging.error("Socket connection errored out. Shutting down AP")
+ finally:
+ connection.close()
+ sock.shutdown(socket.SHUT_RDWR)
+ sock.close()
+
+ def setup_ap(self):
+ bss_settings = []
+ self.access_point = self.access_points[0]
+ network_type = self.user_params["network_type"]
+ if (network_type == "2G"):
+ self.channel = hostapd_constants.AP_DEFAULT_CHANNEL_2G
+ else:
+ self.channel = hostapd_constants.AP_DEFAULT_CHANNEL_5G
+
+ self.ssid = self.user_params["ssid"]
+ self.security = self.user_params["security"]
+ if self.security == "none":
+ self.config = hostapd_ap_preset.create_ap_preset(
+ channel=self.channel,
+ ssid=self.ssid,
+ bss_settings=bss_settings,
+ profile_name='whirlwind')
+ else:
+ self.passphrase = self.user_params["passphrase"]
+ self.hostapd_security = hostapd_security.Security(
+ security_mode=self.security, password=self.passphrase)
+ self.config = hostapd_ap_preset.create_ap_preset(
+ channel=self.channel,
+ ssid=self.ssid,
+ security=self.hostapd_security,
+ bss_settings=bss_settings,
+ profile_name='whirlwind')
+ self.access_point.start_ap(self.config)
+
+ def test_set_up_single_ap(self):
+ req_params = [
+ "AccessPoint", "network_type", "ssid", "passphrase", "security",
+ "socket_port", "socket_timeout_secs"
+ ]
+ opt_params = []
+ self.unpack_userparams(
+ req_param_names=req_params, opt_param_names=opt_params)
+ # Setup the AP environment
+ self.setup_ap()
+ # AP enviroment created. Wait for client to teardown the environment
+ self.wait_for_test_completion()
+
+ def test_set_up_open_ap(self):
+ req_params = [
+ "AccessPoint", "network_type", "ssid", "security", "socket_port",
+ "socket_timeout_secs"
+ ]
+ opt_params = []
+ self.unpack_userparams(
+ req_param_names=req_params, opt_param_names=opt_params)
+ # Setup the AP environment
+ self.setup_ap()
+ # AP enviroment created. Wait for client to teardown the environment
+ self.wait_for_test_completion()
diff --git a/acts/tests/google/wifi/WifiAwareManagerTest.py b/acts/tests/google/wifi/WifiAwareManagerTest.py
deleted file mode 100644
index a3d4874..0000000
--- a/acts/tests/google/wifi/WifiAwareManagerTest.py
+++ /dev/null
@@ -1,1180 +0,0 @@
-#!/usr/bin/python3.4
-#
-# Copyright 2016 - 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 pprint
-import re
-import queue
-import statistics
-import time
-
-from acts import asserts
-from acts import base_test
-from acts.signals import generated_test
-from acts.test_utils.net import connectivity_const as con_const
-from acts.test_utils.net import nsd_const as nsd_const
-from acts.test_utils.wifi import wifi_test_utils as wutils
-from acts.test_utils.wifi import wifi_aware_const as aware_const
-
-# arbitrary timeout for events
-EVENT_TIMEOUT = 30
-
-
-class WifiAwareManagerTest(base_test.BaseTestClass):
- # configuration parameters used by tests
- publish_config = {"ServiceName": "GoogleTestServiceX",
- "ServiceSpecificInfo": "Data XYZ",
- "MatchFilter": {"int0": 14,
- "data0": "MESSAGE_ALL"},
- "PublishType": 0,
- "TtlSec": 0}
- subscribe_config = {"ServiceName": "GoogleTestServiceX",
- "ServiceSpecificInfo": "Data ABC",
- "MatchFilter": {"int0": 14,
- "data0": "MESSAGE_ALL"},
- "SubscribeType": 0,
- "TtlSec": 0}
- rtt_24_20 = {"deviceType": 5,
- "requestType": 2,
- "frequency": 2437,
- "channelWidth": 0,
- "centerFreq0": 2437,
- "centerFreq1": 0,
- "numberBurst": 0,
- "numSamplesPerBurst": 5,
- "numRetriesPerMeasurementFrame": 3,
- "numRetriesPerFTMR": 3,
- "LCIRequest": False,
- "LCRRequest": False,
- "burstTimeout": 15,
- "preamble": 2,
- "bandwidth": 4}
- rtt_50_40 = {"deviceType": 5,
- "requestType": 2,
- "frequency": 5200,
- "channelWidth": 1,
- "centerFreq0": 5190,
- "centerFreq1": 0,
- "numberBurst": 0,
- "numSamplesPerBurst": 5,
- "numRetriesPerMeasurementFrame": 3,
- "numRetriesPerFTMR": 3,
- "LCIRequest": False,
- "LCRRequest": False,
- "burstTimeout": 15,
- "preamble": 2,
- "bandwidth": 8}
- rtt_50_80 = {"deviceType": 5,
- "requestType": 2,
- "frequency": 5200,
- "channelWidth": 2,
- "centerFreq0": 5210,
- "centerFreq1": 0,
- "numberBurst": 0,
- "numSamplesPerBurst": 5,
- "numRetriesPerMeasurementFrame": 3,
- "numRetriesPerFTMR": 3,
- "LCIRequest": False,
- "LCRRequest": False,
- "burstTimeout": 15,
- "preamble": 4,
- "bandwidth": 16}
- network_req = {"TransportType": 5}
- nsd_service_info = {"serviceInfoServiceName": "sl4aTestAwareIperf",
- "serviceInfoServiceType": "_simple-tx-rx._tcp.",
- "serviceInfoPort": 2257}
-
- def setup_test(self):
- self.msg_id = 10
- for ad in self.android_devices:
- wutils.wifi_toggle_state(ad, True)
- aware_usage_enabled = ad.droid.wifiIsAwareAvailable()
- if not aware_usage_enabled:
- self.log.info('Aware not enabled. Waiting for %s',
- aware_const.BROADCAST_WIFI_AWARE_AVAILABLE)
- try:
- ad.ed.pop_event(aware_const.BROADCAST_WIFI_AWARE_AVAILABLE,
- EVENT_TIMEOUT)
- self.log.info(aware_const.BROADCAST_WIFI_AWARE_AVAILABLE)
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s' %
- aware_const.BROADCAST_WIFI_AWARE_AVAILABLE)
-
- def teardown_test(self):
- for ad in self.android_devices:
- ad.droid.wifiAwareDestroyAll()
- # asserts.assert_true(
- # wutils.wifi_toggle_state(ad, False),
- # "Failed disabling Wi-Fi interface")
-
- def extract_stats(self, data, results, key_prefix, log_prefix):
- """Extract statistics from the data, store in the dict dictionary, and
- output to the info log.
-
- Args:
- data: A list containing the data to be analyzed.
- results: A dictionary into which to place the statistics.
- key_prefix: A string prefix to use for the dict keys storing the
- extracted stats.
- log_prefix: A string prefix to use for the info log.
- include_data: If True includes the raw data in the dictionary,
- otherwise just the stats.
- """
- num_samples = len(data)
- results['%s_num_samples' % key_prefix] = num_samples
-
- if not data:
- return
-
- data_min = min(data)
- data_max = max(data)
- data_mean = statistics.mean(data)
-
- results['%s_min' % key_prefix] = data_min
- results['%s_max' % key_prefix] = data_max
- results['%s_mean' % key_prefix] = data_mean
- results['%s_raw_data' % key_prefix] = data
-
- if num_samples > 1:
- data_stdev = statistics.stdev(data)
- results['%s_stdev' % key_prefix] = data_stdev
- self.log.info(
- '%s: num_samples=%d, min=%.2f, max=%.2f, mean=%.2f, stdev=%.2f',
- log_prefix, num_samples, data_min, data_max, data_mean,
- data_stdev)
- else:
- self.log.info('%s: num_samples=%d, min=%.2f, max=%.2f, mean=%.2f',
- log_prefix, num_samples, data_min, data_max,
- data_mean)
-
- def get_interface_mac(self, device, interface):
- """Get the HW MAC address of the specified interface.
-
- Returns the HW MAC address or raises an exception on failure.
-
- Args:
- device: The 'AndroidDevice' on which to query the interface.
- interface: The name of the interface to query.
-
- Returns:
- mac: MAC address of the interface.
- """
- out = device.adb.shell("ifconfig %s" % interface)
- completed = out.decode('utf-8').strip()
- res = re.match(".* HWaddr (\S+).*", completed, re.S)
- asserts.assert_true(
- res, 'Unable to obtain MAC address for interface %s' % interface)
- return res.group(1)
-
- def get_interface_ipv6_link_local(self, device, interface):
- """Get the link-local IPv6 address of the specified interface.
-
- Returns the link-local IPv6 address of the interface or raises an
- exception on failure.
-
- Args:
- device: The 'AndroidDevice' on which to query the interface.
- interface: The name of the interface to query.
-
- Returns:
- addr: link-local IPv6 address of the interface.
- """
- out = device.adb.shell("ifconfig %s" % interface)
- completed = out.decode('utf-8').strip()
- res = re.match(".*inet6 addr: (\S+)/64 Scope: Link.*", completed, re.S)
- asserts.assert_true(
- res,
- 'Unable to obtain IPv6 link-local for interface %s' % interface)
- return res.group(1)
-
- def exec_connect(self, device, name, config=None):
- """Executes the Aware connection creation operation.
-
- Creates an Aware connection (client) and waits for a confirmation event
- of success. Raise test failure signal if no such event received.
-
- Args:
- device: The 'AndroidDevice' on which to set up the connection.
- name: An arbitary name used for logging.
- config: An optional ConfigRequest (JSON-configured) structure.
- """
- session_id = device.droid.wifiAwareAttach(config)
- try:
- event = device.ed.pop_event(aware_const.EVENT_CB_ON_ATTACHED,
- EVENT_TIMEOUT)
- self.log.info('%s: %s', aware_const.EVENT_CB_ON_ATTACHED,
- event['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on %s' %
- (aware_const.EVENT_CB_ON_ATTACHED, name))
- self.log.debug(event)
- return session_id
-
- def reliable_tx(self, device, session_id, peer, msg):
- """Sends an Aware message.
-
- Sends a message to the peer and waits for success confirmation. Raises
- an exception on failure or timeout.
-
- The message is sent using the MAX retransmission count.
-
- Args:
- device: The 'AndroidDevice' on which to send the message.
- session_id: The session ID context from which to send the message.
- This is the value returned by wifiAwarePublish() or
- wifiAwareSubscribe().
- peer: The peer ID to send the message to. Obtained through a match
- or a received message.
- msg: The message to be transmitted to the peer.
- """
- events_regex = '%s|%s' % (aware_const.SESSION_CB_ON_MESSAGE_SEND_FAILED,
- aware_const.SESSION_CB_ON_MESSAGE_SENT)
- self.msg_id = self.msg_id + 1
-
- while True:
- try:
- device.droid.wifiAwareSendMessage(session_id, peer, self.msg_id,
- msg,
- aware_const.MAX_TX_RETRIES)
- events = device.ed.pop_events(events_regex, EVENT_TIMEOUT)
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s', events_regex)
-
- for event in events:
- self.log.info('%s: %s', event['name'], event['data'])
- if event['data']['messageId'] == self.msg_id:
- asserts.assert_equal(event['name'],
- aware_const.SESSION_CB_ON_MESSAGE_SENT,
- 'Failed (re)transmission')
- return
-
- def exec_rtt(self, device, session_id, peer_id, rtt_param, label,
- repeat_count):
- """Executes an RTT operation.
-
- Args:
- device: The 'AndroidDevice' on which to send the message.
- session_id: The session ID context from which to send the message.
- This is the value returned by wifiAwarePublish() or
- wifiAwareSubscribe().
- peer_id: The peer ID to send the message to. Obtained through a
- match or a received message.
- rtt_param: RTT session parameters.
- msg: Message/tag describing RTT experiment.
- repeat_count: Number of RTT measurements to execute.
- """
- rtt_param['bssid'] = peer_id
- rtt_stats = {
- 'failure_codes': {},
- 'distance': {
- 'sum': 0,
- 'num_samples': 0
- }
- }
- for i in range(repeat_count):
- device.droid.wifiAwareStartRanging(0, session_id, [rtt_param])
-
- events_regex = '%s|%s|%s' % (aware_const.RTT_LISTENER_CB_ON_SUCCESS,
- aware_const.RTT_LISTENER_CB_ON_FAILURE,
- aware_const.RTT_LISTENER_CB_ON_ABORT)
- try:
- events_pub_range = device.ed.pop_events(events_regex,
- EVENT_TIMEOUT)
- for event in events_pub_range:
- self.log.debug('%s: %s: %s', label, event['name'],
- event['data'])
- results = event['data']['Results']
- for rtt_result in results:
- rtt_status = rtt_result['status']
- if rtt_status == 0:
- distance = rtt_result['distance']
- self.log.info('%s: distance=%d', label, distance)
- rtt_stats['distance']['sum'] = (
- rtt_stats['distance']['sum'] + distance)
- rtt_stats['distance']['num_samples'] = (
- rtt_stats['distance']['num_samples'] + 1)
- else:
- self.log.info('%s: status=%d', label, rtt_status)
- if rtt_status not in rtt_stats['failure_codes']:
- rtt_stats['failure_codes'][rtt_status] = 0
- rtt_stats['failure_codes'][rtt_status] = (
- rtt_stats['failure_codes'][rtt_status] + 1)
- except queue.Empty:
- self.log.info('%s: Timed out while waiting for RTT events %s',
- label, events_regex)
- self.log.info('%s:\n\tParam: %s\n\tRTT statistics: %s', label,
- rtt_param, rtt_stats)
-
- def test_cluster_latency(self):
- """Measure the time it takes to make Aware available to an app from
- the time a request is made.
-
- Configuration: 1 device
-
- Logical steps:
- * DUT initiate Aware clustering
- * DUT wait for attach event (measure time)
- * DUT wait for identity change event (measure time)
- * DUT destroy Aware session
- """
- results = {}
- results['num_iterations'] = 100
-
- self.dut = self.android_devices[0]
-
- attach_latency = []
- identity_change_latency = []
- results['num_failed_attaches'] = 0
- for i in range(results['num_iterations']):
- session_id = self.dut.droid.wifiAwareAttach()
- try:
- event_attached = self.dut.ed.pop_event(
- aware_const.EVENT_CB_ON_ATTACHED, EVENT_TIMEOUT)
- attach_latency.append(event_attached['data'][
- aware_const.EVENT_CB_KEY_LATENCY_MS])
- self.log.debug('%s: %s', aware_const.EVENT_CB_ON_ATTACHED,
- event_attached['data'])
-
- event_identity_change = self.dut.ed.pop_event(
- aware_const.EVENT_CB_ON_IDENTITY_CHANGED, EVENT_TIMEOUT)
- identity_change_latency.append(event_identity_change['data'][
- aware_const.EVENT_CB_KEY_TIMESTAMP_MS] - event_attached[
- 'data'][
- aware_const.SESSION_CB_KEY_TIMESTAMP_MS])
- except queue.Empty:
- results['num_failed_attaches'] += 1
- self.log.debug('Timed out while waiting for %s|%s on DUT',
- aware_const.EVENT_CB_ON_ATTACHED,
- aware_const.EVENT_CB_ON_IDENTITY_CHANGED)
- self.dut.droid.wifiAwareDestroy(session_id)
-
- self.extract_stats(attach_latency, results, 'attach_latency', 'Attach')
- self.extract_stats(identity_change_latency, results,
- 'identity_change_latency', 'Identity Change')
- asserts.explicit_pass('test_cluster_latency finished', extras=results)
-
- def run_aware_discovery_session(self, discovery_config):
- """Perform Aware configuration, discovery, and message exchange.
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S initiate Aware clustering (if not already up)
- * P & S wait for Aware connection confirmation
- * P starts publishing
- * S starts subscribing
- * S waits for a match (discovery) notification
- * S sends a message to P, confirming that sent successfully
- * P waits for a message and confirms that received (uncorrupted)
- * P sends a message to S, confirming that sent successfully
- * S waits for a message and confirms that received (uncorrupted)
-
- Args:
- discovery_configs: {'Title': description,
- 'PublishConfig': publish_config,
- 'SubscribeConfig': subscribe_config}
-
- Returns:
- True if discovery succeeds, else false.
- """
- # Configure Test
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
-
- sub2pub_msg = "How are you doing? 你好嗎？"
- pub2sub_msg = "Doing ok - thanks! 做的不錯 - 謝謝！"
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher")
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber")
-
- # Configuration
- publish_config = discovery_config['PublishConfig']
- subscribe_config = discovery_config['SubscribeConfig']
- self.log.debug('Publish config=%s, Subscribe config=%s', publish_config,
- subscribe_config)
-
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- publish_config)
- sub_id = self.subscriber.droid.wifiAwareSubscribe(sub_connect_id,
- subscribe_config)
-
- try:
- event_sub_match = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_sub_match['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber' %
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.log.debug(event_sub_match)
-
- self.reliable_tx(self.subscriber, sub_id,
- event_sub_match['data']['peerId'], sub2pub_msg)
-
- try:
- event_pub_rx = self.publisher.ed.pop_event(
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, EVENT_TIMEOUT)
- self.log.info('%s: %s', aware_const.SESSION_CB_ON_MESSAGE_RECEIVED,
- event_pub_rx['data'])
- asserts.assert_equal(event_pub_rx['data']['messageAsString'],
- sub2pub_msg,
- "Subscriber -> publisher message corrupted")
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on publisher' %
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED)
-
- self.reliable_tx(self.publisher, pub_id, event_pub_rx['data']['peerId'],
- pub2sub_msg)
-
- try:
- event_sub_rx = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, EVENT_TIMEOUT)
- self.log.info('%s: %s', aware_const.SESSION_CB_ON_MESSAGE_RECEIVED,
- event_sub_rx['data'])
- asserts.assert_equal(event_sub_rx['data']['messageAsString'],
- pub2sub_msg,
- "Publisher -> subscriber message corrupted")
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on subscriber' %
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED)
-
- if publish_config['TtlSec'] != 0:
- try:
- event_pub_term = self.publisher.ed.pop_event(
- aware_const.SESSION_CB_ON_SESSION_TERMINATED,
- publish_config['TtlSec'] + 5)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SESSION_TERMINATED,
- event_pub_term['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on publisher' %
- aware_const.SESSION_CB_ON_SESSION_TERMINATED)
- if subscribe_config['TtlSec'] != 0:
- try:
- event_sub_term = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SESSION_TERMINATED,
- subscribe_config['TtlSec'] + 5)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SESSION_TERMINATED,
- event_sub_term['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on subscriber' %
- aware_const.SESSION_CB_ON_SESSION_TERMINATED)
-
- @generated_test
- def test_aware_discovery_session(self):
- """Perform Aware configuration, discovery, and message exchange.
-
- Test multiple discovery types:
- - Unsolicited publish + passive subscribe
- - Solicited publish + active subscribe
- """
-
- discovery_configs = (
- {'Title': 'ActivePub',
- 'PublishConfig': self.publish_config,
- 'SubscribeConfig': self.subscribe_config},
- {'Title': 'ActiveSub',
- 'PublishConfig': dict(self.publish_config, **{'PublishType': 1}),
- 'SubscribeConfig': dict(self.subscribe_config,
- **{'SubscribeType': 1})},
- {'Title': 'ActivePub-LimitedTtl',
- 'PublishConfig': dict(self.publish_config, **{"TtlSec": 20}),
- 'SubscribeConfig': dict(self.subscribe_config, **{"TtlSec": 20})})
- name_func = lambda discovery_config: ("test_aware_discovery_session__%s") % discovery_config['Title']
- self.run_generated_testcases(self.run_aware_discovery_session,
- discovery_configs,
- name_func=name_func)
-
- def run_aware_discovery_latency(self, dw_interval):
- """Measure the latency of Aware discovery on the subscriber.
-
- Args:
- dw_interval: Discovery Window Interval configuration
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S if not new_session initiate Aware clustering (if not already up)
- * P & S if not new session wait for Aware connection confirmation
- * P starts publishing
- * Wait for a few seconds to make sure everyone is ready (measuring
- * discovery - not clustering).
- * Loop:
- * S start subscribing
- * Measure latency to S registering a discovery
- * S terminates subscribe
- """
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
- results = {}
- results['num_iterations'] = 100
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher",
- {"DiscoveryWindowInterval": [dw_interval, dw_interval]})
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber",
- {"DiscoveryWindowInterval": [dw_interval, dw_interval]})
-
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- self.publish_config)
- try:
- self.publisher.ed.pop_event(
- aware_const.SESSION_CB_ON_PUBLISH_STARTED, EVENT_TIMEOUT)
- except:
- asserts.fail('Timed out while waiting for %s on Publisher' %
- aware_const.SESSION_CB_ON_PUBLISH_STARTED)
-
- # another arbitrary long sleep time to make sure that publisher is
- # on-the-air
- time.sleep(10)
-
- sub_session_setup_latency = []
- sub_session_discovery_latency = []
- results['num_failed_discovery'] = 0
- for i in range(results['num_iterations']):
- sub_id = self.subscriber.droid.wifiAwareSubscribe(
- sub_connect_id, self.subscribe_config)
- try:
- event_sub = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SUBSCRIBE_STARTED, EVENT_TIMEOUT)
- sub_session_setup_latency.append(event_sub['data'][
- aware_const.SESSION_CB_KEY_LATENCY_MS])
- self.log.debug('%s: %s',
- aware_const.SESSION_CB_ON_SUBSCRIBE_STARTED,
- event_sub['data'])
-
- event_discovery = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- sub_session_discovery_latency.append(event_discovery['data'][
- aware_const.SESSION_CB_KEY_TIMESTAMP_MS] - event_sub[
- 'data'][aware_const.SESSION_CB_KEY_TIMESTAMP_MS])
- self.log.debug('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_discovery['data'])
- except queue.Empty:
- results['num_failed_discovery'] += 1
- self.log.debug(
- 'Timed out while waiting for %s|%s on Subscriber',
- aware_const.SESSION_CB_ON_SUBSCRIBE_STARTED,
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.subscriber.droid.wifiAwareDestroyDiscoverySession(sub_id)
-
- self.extract_stats(sub_session_setup_latency, results,
- 'sub_session_setup_latency',
- 'Subscribe Session Setup')
- self.extract_stats(sub_session_discovery_latency, results,
- 'sub_session_discovery_latency',
- 'Subscribe Session Discovery')
- asserts.explicit_pass('test_aware_discovery_latency finished',
- extras=results)
-
- @generated_test
- def test_aware_discovery_latency(self):
- """Measure the latency of Aware discovery on the subscriber.
-
- Test different discovery window intervals: 1, 2, 3, 4, 5
- """
-
- name_func = lambda dw_interval: "test_aware_discovery_latency__dw_%d" % dw_interval
- self.run_generated_testcases(self.run_aware_discovery_latency,
- [1, 2, 3, 4, 5],
- name_func=name_func)
-
- def run_aware_messaging(self, retry_count):
- """Perform Aware configuration, discovery, and large message exchange.
-
- Args:
- retry_count: retransmission count - from 0 to aware_const.MAX_TX_RETRIES
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S initiate Aware clustering (if not already up)
- * P & S wait for Aware connection confirmation
- * P starts publishing
- * S starts subscribing
- * S waits for a match (discovery) notification
- * S sends XX messages to P
- * S confirms that all XXX messages were transmitted
- * P confirms that all XXX messages are received
- """
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
- results = {}
- results['num_non_empty_messages'] = 100
- results[
- 'num_null_and_empty_messages'] = 10 # one of each in sequence until reach count
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher")
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber")
-
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- self.publish_config)
- sub_id = self.subscriber.droid.wifiAwareSubscribe(sub_connect_id,
- self.subscribe_config)
-
- try:
- event_sub_match = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_sub_match['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber' %
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.log.debug(event_sub_match)
-
- # send all messages at once
- for i in range(results['num_non_empty_messages']):
- self.msg_id = self.msg_id + 1
- self.subscriber.droid.wifiAwareSendMessage(
- sub_id, event_sub_match['data']['peerId'], self.msg_id,
- "msg %s" % i, retry_count)
-
- # send all empty & null messages
- for i in range(results['num_null_and_empty_messages']):
- self.msg_id = self.msg_id + 1
- msg_to_send = None if (i % 2) else "" # flip between null and ""
- self.subscriber.droid.wifiAwareSendMessage(
- sub_id, event_sub_match['data']['peerId'], self.msg_id,
- msg_to_send, retry_count)
-
- # wait for all messages to be transmitted correctly
- results['num_tx_ok'] = 0
- results['num_tx_fail'] = 0
- tx_ok_stats = []
- tx_fail_stats = []
- events_regex = '%s|%s' % (aware_const.SESSION_CB_ON_MESSAGE_SEND_FAILED,
- aware_const.SESSION_CB_ON_MESSAGE_SENT)
- while (results['num_tx_ok'] + results['num_tx_fail']) < (
- results['num_non_empty_messages'] +
- results['num_null_and_empty_messages']):
- try:
- events = self.subscriber.ed.pop_events(events_regex,
- EVENT_TIMEOUT)
-
- for event in events:
- if event['name'] == aware_const.SESSION_CB_ON_MESSAGE_SENT:
- results['num_tx_ok'] = results['num_tx_ok'] + 1
- if aware_const.SESSION_CB_KEY_LATENCY_MS in event[
- 'data']:
- tx_ok_stats.append(event['data'][
- aware_const.SESSION_CB_KEY_LATENCY_MS])
- if event[
- 'name'] == aware_const.SESSION_CB_ON_MESSAGE_SEND_FAILED:
- results['num_tx_fail'] = results['num_tx_fail'] + 1
- if aware_const.SESSION_CB_KEY_LATENCY_MS in event[
- 'data']:
- tx_fail_stats.append(event['data'][
- aware_const.SESSION_CB_KEY_LATENCY_MS])
- except queue.Empty:
- self.log.warning('Timed out while waiting for %s on Subscriber'
- ' - %d events received', events_regex,
- results['num_tx_ok'] + results['num_tx_fail'])
- break
- self.log.info('Transmission stats: %d success, %d fail',
- results['num_tx_ok'], results['num_tx_fail'])
- self.extract_stats(tx_ok_stats, results, 'tx_ok_latency',
- 'Successful tx')
- self.extract_stats(tx_fail_stats, results, 'tx_fail_latency', 'Fail tx')
-
- # validate that all messages are received (not just the correct
- # number of messages - since on occasion there may be duplicates
- # received).
- results['num_non_empty_received'] = 0
- results['num_unique_received'] = 0
- results['num_empty_received'] = 0
- messages = {}
- while (results['num_unique_received'] + results['num_empty_received'] <
- results['num_tx_ok']):
- try:
- event = self.publisher.ed.pop_event(
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, EVENT_TIMEOUT)
- msg = event['data']['messageAsString']
- if msg:
- results['num_non_empty_received'] = results[
- 'num_non_empty_received'] + 1
- if msg not in messages:
- results['num_unique_received'] = results[
- 'num_unique_received'] + 1
- messages[msg] = 0
- messages[msg] = messages[msg] + 1
- else:
- results['num_empty_received'] = results[
- 'num_empty_received'] + 1
- self.log.debug('%s: %s',
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, msg)
- except queue.Empty:
- asserts.fail(
- 'Timed out while waiting for %s on Publisher: %d non-empty '
- 'messages received, %d unique messages, %d empty messages' %
- (aware_const.SESSION_CB_ON_MESSAGE_RECEIVED,
- results['num_non_empty_received'],
- results['num_unique_received'],
- results['num_empty_received']),
- extras=results)
- self.log.info(
- 'Reception stats: %d non-empty received (%d unique), %d empty',
- results['num_non_empty_received'], results['num_unique_received'],
- results['num_empty_received'])
- if results['num_non_empty_received'] != results['num_unique_received']:
- self.log.info('%d duplicate receptions of %d messages: %s',
- results['num_non_empty_received'] -
- results['num_unique_received'],
- results['num_non_empty_received'], messages)
- if results['num_empty_received'] != results[
- 'num_null_and_empty_messages']:
- self.log.info('%d extra empty/null message reception',
- results['num_empty_received'] -
- results['num_null_and_empty_messages'])
- asserts.explicit_pass("run_aware_messaging pass finished successfully",
- extras=results)
-
- @generated_test
- def test_aware_messaging(self):
- """Perform Aware configuration, discovery, and large message exchange.
-
- Test multiple message send retry counts.
- """
- name_func = lambda retry_count: "test_aware_messaging__retries_%d" % retry_count
- self.run_generated_testcases(self.run_aware_messaging,
- [0, aware_const.MAX_TX_RETRIES],
- name_func=name_func)
-
- def test_aware_messaging_latency(self):
- """Measure the latency of Aware message transmission which are not queued. Unqueued
- message transmission data is a function of raw protocol and firmware behavior.
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S initiate Aware clustering (if not already up)
- * P & S wait for Aware connection confirmation
- * P starts publishing
- * S starts subscribing
- * S waits for a match (discovery) notification
- * Loop:
- * S sends 1 message to P
- * S confirms that message transmitted and measures latency
- """
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
- results = {}
- results['num_messages'] = 100
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher")
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber")
-
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- self.publish_config)
- sub_id = self.subscriber.droid.wifiAwareSubscribe(sub_connect_id,
- self.subscribe_config)
-
- try:
- event_sub_match = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_sub_match['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber' %
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.log.debug(event_sub_match)
-
- results['num_tx_ok'] = 0
- results['num_tx_fail'] = 0
- tx_ok_stats = []
- tx_fail_stats = []
- events_regex = '%s|%s' % (aware_const.SESSION_CB_ON_MESSAGE_SEND_FAILED,
- aware_const.SESSION_CB_ON_MESSAGE_SENT)
- for i in range(results['num_messages']):
- self.msg_id = self.msg_id + 1
- self.subscriber.droid.wifiAwareSendMessage(
- sub_id, event_sub_match['data']['peerId'], self.msg_id,
- "msg %s" % i, 0)
- try:
- events = self.subscriber.ed.pop_events(events_regex,
- EVENT_TIMEOUT)
- for event in events:
- if event['name'] == aware_const.SESSION_CB_ON_MESSAGE_SENT:
- results['num_tx_ok'] = results['num_tx_ok'] + 1
- if aware_const.SESSION_CB_KEY_LATENCY_MS in event[
- 'data']:
- tx_ok_stats.append(event['data'][
- aware_const.SESSION_CB_KEY_LATENCY_MS])
- if event[
- 'name'] == aware_const.SESSION_CB_ON_MESSAGE_SEND_FAILED:
- results['num_tx_fail'] = results['num_tx_fail'] + 1
- if aware_const.SESSION_CB_KEY_LATENCY_MS in event[
- 'data']:
- tx_fail_stats.append(event['data'][
- aware_const.SESSION_CB_KEY_LATENCY_MS])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber',
- events_regex,
- extras=results)
- self.extract_stats(tx_ok_stats, results, 'tx_ok_latency',
- 'Successful tx')
- self.extract_stats(tx_fail_stats, results, 'tx_fail_latency', 'Fail tx')
- asserts.explicit_pass(
- 'test_aware_messaging_no_queue finished successfully',
- extras=results)
-
- def test_aware_rtt(self):
- """Perform Aware configuration, discovery, and RTT.
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S initiate Aware clustering (if not already up)
- * P & S wait for Aware connection confirmation
- * P starts publishing
- * S starts subscribing
- * S waits for a match (discovery) notification
- * S performs 3 RTT measurements with P
- """
- # Configure Test
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
- rtt_iterations = 10
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher")
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber")
-
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- self.publish_config)
- sub_id = self.subscriber.droid.wifiAwareSubscribe(sub_connect_id,
- self.subscribe_config)
-
- try:
- event_sub_match = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_sub_match['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber' %
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.log.debug(event_sub_match)
-
- self.exec_rtt(device=self.subscriber,
- session_id=sub_id,
- peer_id=event_sub_match['data']['peerId'],
- rtt_param=self.rtt_24_20, label="2.4GHz / 20MHz BW",
- repeat_count=rtt_iterations)
- self.exec_rtt(device=self.subscriber,
- session_id=sub_id,
- peer_id=event_sub_match['data']['peerId'],
- rtt_param=self.rtt_50_40, label="5Hz / 40MHz BW",
- repeat_count=rtt_iterations)
- self.exec_rtt(device=self.subscriber,
- session_id=sub_id,
- peer_id=event_sub_match['data']['peerId'],
- rtt_param=self.rtt_50_80, label="5GHz / 80MHz BW",
- repeat_count=rtt_iterations)
-
- def test_disable_wifi_during_connection(self):
- """Validate behavior when Wi-Fi is disabled during an active Aware
- connection. Expected behavior: receive an onAwareDown(1002) event.
-
- Configuration: 1 device - the DUT.
-
- Logical steps:
- * DUT initiate Aware clustering (if not already up)
- * DUT waits for Aware connection confirmation
- * DUT starts publishing
- * Disable Wi-Fi
- * DUT waits for an onAwareDown(1002) event and confirms that received
- """
- # Configure Test
- self.dut = self.android_devices[0]
-
- # Start Test
- connect_id = self.dut.droid.wifiAwareAttach()
-
- try:
- event = self.dut.ed.pop_event(aware_const.EVENT_CB_ON_ATTACHED,
- EVENT_TIMEOUT)
- self.log.info('%s: %s', aware_const.EVENT_CB_ON_ATTACHED,
- event['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on dut' %
- aware_const.EVENT_CB_ON_ATTACHED)
- self.log.debug(event)
-
- pub_id = self.dut.droid.wifiAwarePublish(connect_id,
- self.publish_config)
-
- asserts.assert_true(
- wutils.wifi_toggle_state(self.dut, False),
- "Failed disabling Wi-Fi interface on dut")
-
- try:
- event = self.dut.ed.pop_event(
- aware_const.BROADCAST_WIFI_AWARE_NOT_AVAILABLE, EVENT_TIMEOUT)
- self.log.info(aware_const.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on dut' %
- aware_const.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
- self.log.debug(event)
-
- def test_aware_data_path(self):
- """Perform Aware configuration, discovery, data-path setup, and data
- transfer.
-
- Configuration: 2 devices, one acting as Publisher (P) and the
- other as Subscriber (S)
-
- Logical steps:
- * P & S initiate Aware clustering (if not already up)
- * P & S wait for Aware connection confirmation
- * P starts publishing
- * S starts subscribing
- * S waits for a match (discovery) notification
- * S sends a message to P
- * P waits for message
- * P creates an Aware network to S as RESPONDER
- * P sends a message to S
- * S waits for message
- * S creates an Aware network to P as INITIATOR (order important!)
- * Both P & S wait for events confirming network set up
- * NSD option:
- * P registers NSD service
- * S discovers NSD service and obtains P's IPv6 address
- * Direct config option:
- * No communication: script uses address read from P
- * run iperf3 between P (server) and S (client)
- * unregister network callback on S
- """
- # Configure Test
- self.publisher = self.android_devices[0]
- self.subscriber = self.android_devices[1]
- results = {}
-
- sub2pub_msg = "Get ready!"
- pub2sub_msg = "Ready!"
- publisher_passphrase = None
- subscriber_passphrase = None
- use_nsd = False
-
- # Start Test
- pub_connect_id = self.exec_connect(self.publisher, "publisher")
- sub_connect_id = self.exec_connect(self.subscriber, "subscriber")
-
- # Discovery: publish + subscribe + wait for match
- pub_id = self.publisher.droid.wifiAwarePublish(pub_connect_id,
- self.publish_config)
- sub_id = self.subscriber.droid.wifiAwareSubscribe(sub_connect_id,
- self.subscribe_config)
-
- def filter_callbacks(event, key, name):
- return event['data'][key] == name
-
- try:
- event_sub_match = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED, EVENT_TIMEOUT)
- self.log.info('%s: %s',
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED,
- event_sub_match['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Subscriber' %
- aware_const.SESSION_CB_ON_SERVICE_DISCOVERED)
- self.log.debug(event_sub_match)
-
- # S sends message to P
- self.reliable_tx(self.subscriber, sub_id,
- event_sub_match['data']['peerId'], sub2pub_msg)
-
- try:
- event_pub_rx = self.publisher.ed.pop_event(
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, EVENT_TIMEOUT)
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on publisher' %
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED)
- self.log.info('%s: %s', aware_const.SESSION_CB_ON_MESSAGE_RECEIVED,
- event_pub_rx['data'])
- asserts.assert_equal(event_pub_rx['data']['messageAsString'],
- sub2pub_msg,
- "Subscriber -> publisher message corrupted")
-
- # P requests an Aware network as RESPONDER
- pub_ns = self.publisher.droid.wifiAwareCreateNetworkSpecifier(pub_id,
- event_pub_rx['data']['peerId'], publisher_passphrase)
- self.log.info("Publisher network specifier - '%s'", pub_ns)
- self.network_req['NetworkSpecifier'] = pub_ns
- pub_req_key = self.publisher.droid.connectivityRequestWifiAwareNetwork(
- self.network_req)
-
- # P sends message to S
- self.reliable_tx(self.publisher, pub_id, event_pub_rx['data']['peerId'],
- pub2sub_msg)
-
- try:
- event_sub_rx = self.subscriber.ed.pop_event(
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED, EVENT_TIMEOUT)
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on subscriber' %
- aware_const.SESSION_CB_ON_MESSAGE_RECEIVED)
- self.log.info('%s: %s', aware_const.SESSION_CB_ON_MESSAGE_RECEIVED,
- event_sub_rx['data'])
- asserts.assert_equal(event_sub_rx['data']['messageAsString'],
- pub2sub_msg,
- "Publisher -> subscriber message corrupted")
-
- # S requests an Aware network as INITIATOR
- sub_ns = self.subscriber.droid.wifiAwareCreateNetworkSpecifier(sub_id,
- event_sub_rx['data']['peerId'], subscriber_passphrase)
- self.log.info("Subscriber network specifier - '%s'", sub_ns)
- self.network_req['NetworkSpecifier'] = sub_ns
- sub_req_key = self.subscriber.droid.connectivityRequestWifiAwareNetwork(
- self.network_req)
-
- # Wait until both S and P get confirmation that network formed
- try:
- event_network = self.subscriber.ed.wait_for_event(
- con_const.EVENT_NETWORK_CALLBACK,
- filter_callbacks,
- EVENT_TIMEOUT,
- key=con_const.NETWORK_CB_KEY_EVENT,
- name=con_const.NETWORK_CB_LINK_PROPERTIES_CHANGED)
- self.log.info('Subscriber %s: %s', con_const.EVENT_NETWORK_CALLBACK,
- event_network['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s/%s on Subscriber' %
- (con_const.EVENT_NETWORK_CALLBACK,
- con_const.NETWORK_CB_LINK_PROPERTIES_CHANGED))
- self.log.debug(event_network)
- sub_aware_if = event_network['data']['interfaceName']
-
- try:
- event_network = self.publisher.ed.wait_for_event(
- con_const.EVENT_NETWORK_CALLBACK,
- filter_callbacks,
- EVENT_TIMEOUT,
- key=con_const.NETWORK_CB_KEY_EVENT,
- name=con_const.NETWORK_CB_LINK_PROPERTIES_CHANGED)
- self.log.info('Publisher %s: %s', con_const.EVENT_NETWORK_CALLBACK,
- event_network['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s/%s on Publisher' %
- (con_const.EVENT_NETWORK_CALLBACK,
- con_const.NETWORK_CB_LINK_PROPERTIES_CHANGED))
- self.log.debug(event_network)
- pub_aware_if = event_network['data']['interfaceName']
-
- pub_ipv6 = "";
- if use_nsd:
- try:
- # P registers NSD service (i.e. starts publishing)
- nsd_reg = self.publisher.droid.nsdRegisterService(
- self.nsd_service_info)
- try:
- event_nsd = self.publisher.ed.wait_for_event(
- nsd_const.REG_LISTENER_EVENT,
- filter_callbacks,
- EVENT_TIMEOUT,
- key=nsd_const.REG_LISTENER_CALLBACK,
- name=nsd_const.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED)
- self.log.info(
- 'Publisher %s: %s',
- nsd_const.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED,
- event_nsd['data'])
- except queue.Empty:
- asserts.fail('Timed out while waiting for %s on Publisher' %
- nsd_const.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED)
-
- # S starts NSD discovery
- nsd_discovery = self.subscriber.droid.nsdDiscoverServices(
- self.nsd_service_info[
- nsd_const.NSD_SERVICE_INFO_SERVICE_TYPE])
- try:
- event_nsd = self.subscriber.ed.wait_for_event(
- nsd_const.DISCOVERY_LISTENER_EVENT,
- filter_callbacks,
- EVENT_TIMEOUT,
- key=nsd_const.DISCOVERY_LISTENER_DATA_CALLBACK,
- name=nsd_const.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND)
- self.log.info(
- 'Subscriber %s: %s',
- nsd_const.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND,
- event_nsd['data'])
- except queue.Empty:
- asserts.fail(
- 'Timed out while waiting for %s on Subscriber' %
- nsd_const.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND)
-
- # S resolves IP address of P from NSD service discovery
- self.subscriber.droid.nsdResolveService(event_nsd['data'])
- try:
- event_nsd = self.subscriber.ed.wait_for_event(
- nsd_const.RESOLVE_LISTENER_EVENT,
- filter_callbacks,
- EVENT_TIMEOUT,
- key=nsd_const.RESOLVE_LISTENER_DATA_CALLBACK,
- name=nsd_const.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED)
- self.log.info(
- 'Subscriber %s: %s',
- nsd_const.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED,
- event_nsd['data'])
- except queue.Empty:
- asserts.fail(
- 'Timed out while waiting for %s on Subscriber' %
- nsd_const.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED)
-
- # mDNS returns first character as '/' - strip
- # out to get clean IPv6
- pub_ipv6 = event_nsd['data'][
- nsd_const.NSD_SERVICE_INFO_HOST][1:]
- finally:
- # Stop NSD
- if nsd_reg is not None:
- self.publisher.droid.nsdUnregisterService(nsd_reg)
- if nsd_discovery is not None:
- self.subscriber.droid.nsdStopServiceDiscovery(nsd_discovery)
- else:
- pub_ipv6 = self.publisher.droid.connectivityGetLinkLocalIpv6Address(
- pub_aware_if)
- pub_ipv6 = pub_ipv6.split('%')[0] # get rid of <name> - xx:xx%<name>
- self.log.info('Publisher IPv6: %s', pub_ipv6)
-
- # P starts iPerf server
- result, data = self.publisher.run_iperf_server("-D")
- asserts.assert_true(result, "Can't start iperf3 server")
-
- # S starts iPerf client
- result, data = self.subscriber.run_iperf_client(
- "%s%%%s" % (pub_ipv6, sub_aware_if), "-6 -J")
- self.log.debug(data)
- asserts.assert_true(result,
- "Failure starting/running iperf3 in client mode")
- self.log.debug(pprint.pformat(data))
- data_json = json.loads(''.join(data))
- results['tx_rate'] = data_json['end']['sum_sent']['bits_per_second']
- results['rx_rate'] = data_json['end']['sum_received']['bits_per_second']
- self.log.info('iPerf3: Sent = %d bps Received = %d bps',
- results['tx_rate'], results['rx_rate'])
- asserts.explicit_pass('Aware data-path test passes', extras=results)
diff --git a/acts/tests/google/wifi/aware/README.md b/acts/tests/google/wifi/aware/README.md
new file mode 100644
index 0000000..11a8296
--- /dev/null
+++ b/acts/tests/google/wifi/aware/README.md
@@ -0,0 +1,50 @@
+# Wi-Fi Aware Integrated (ACTS/sl4a) Test Suite
+
+This directory contains ACTS/sl4a test scripts to verify and characterize
+the Wi-Fi Aware implementation in Android.
+
+There are 4 groups of tests (in 4 sub-directories):
+
+* functional: Functional tests that each implementation must pass. These
+are pass/fail tests.
+* performance: Tests which measure performance of an implementation - e.g.
+latency or throughput. Some of the tests may not have pass/fail results -
+they just record the measured performance. Even when tests do have a pass/
+fail criteria - that criteria may not apply to all implementations.
+* stress: Tests which run through a large number of iterations to stress
+test the implementation. Considering that some failures are expected,
+especially in an over-the-air situation, pass/fail criteria are either
+not provided or may not apply to all implementations or test environments.
+* ota (over-the-air): A small number of tests which configure the device
+in a particular mode and expect the tester to capture an over-the-air
+sniffer trace and analyze it for validity. These tests are **not** automated.
+
+The tests can be executed in several ways:
+
+1. Individual test(s): `act.py -c <config> -tc {<test_class>|<test_class>:<test_name>}`
+
+Where a test file is any of the `.py` files in any of the test sub-directories.
+If a test class is specified, then all tests within that test class are executed.
+
+2. All tests in a test group: `act.py -c <config> -tf <test_file>`
+
+Where `<test_file>` is a file containing a list of tests. Each of the test
+group sub-directories contains a file with the same name as that of the
+directory which lists all tests in the directory. E.g. to execute all functional
+tests execute:
+
+`act.py -c <config> -tf ./tools/test/connectivity/acts/tests/google/wifi/aware/functional/functional`
+
+## Test Configurations
+The test configurations, the `<config>` in the commands above, are stored in
+the *config* sub-directory. The configurations simply use all connected
+devices without listing specific serial numbers. Note that some tests use a
+single device while others use 2 devices. In addition, the configurations
+define the following key to configure the test:
+
+* **aware_default_power_mode**: The power mode in which to run all tests. Options
+are `INTERACTIVE` and `NON_INTERACTIVE`.
+
+The following configurations are provided:
+* wifi_aware.json: Normal (high power/interactive) test mode.
+* wifi_aware_non_interactive.json: Low power (non-interactive) test mode.
diff --git a/acts/tests/google/wifi/aware/config/wifi_aware.json b/acts/tests/google/wifi/aware/config/wifi_aware.json
new file mode 100644
index 0000000..97323fc
--- /dev/null
+++ b/acts/tests/google/wifi/aware/config/wifi_aware.json
@@ -0,0 +1,15 @@
+{
+ "_description": "This is a test configuration file for Wi-Fi Aware tests in INTERACTIVE (high-power) mode.",
+ "testbed":
+ [
+ {
+ "_description": "Wi-Fi Aware testbed: auto-detect all attached devices",
+ "name": "WifiAwareAllAttached",
+ "AndroidDevice": "*"
+ }
+ ],
+ "logpath": "~/logs",
+ "testpaths": ["./tools/test/connectivity/acts/tests/google/wifi"],
+ "adb_logcat_param": "-b all",
+ "aware_default_power_mode": "INTERACTIVE"
+}
diff --git a/acts/tests/google/wifi/aware/config/wifi_aware_non_interactive.json b/acts/tests/google/wifi/aware/config/wifi_aware_non_interactive.json
new file mode 100644
index 0000000..f2e6e79
--- /dev/null
+++ b/acts/tests/google/wifi/aware/config/wifi_aware_non_interactive.json
@@ -0,0 +1,15 @@
+{
+ "_description": "This is a test configuration file for Wi-Fi Aware tests in NON-INTERACTIVE (low-power) mode.",
+ "testbed":
+ [
+ {
+ "_description": "Wi-Fi Aware testbed: auto-detect all attached devices",
+ "name": "WifiAwareAllAttached",
+ "AndroidDevice": "*"
+ }
+ ],
+ "logpath": "~/logs",
+ "testpaths": ["./tools/test/connectivity/acts/tests/google/wifi"],
+ "adb_logcat_param": "-b all",
+ "aware_default_power_mode": "NON_INTERACTIVE"
+}
diff --git a/acts/tests/google/wifi/aware/functional/AttachTest.py b/acts/tests/google/wifi/aware/functional/AttachTest.py
new file mode 100644
index 0000000..191a26f
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/AttachTest.py
@@ -0,0 +1,127 @@
+#!/usr/bin/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 time
+
+from acts.test_utils.wifi import wifi_test_utils as wutils
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+from acts.utils import force_airplane_mode
+
+
+class AttachTest(AwareBaseTest):
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def test_attach(self):
+ """Functional test case / Attach test cases / attach
+
+ Validates that attaching to the Wi-Fi Aware service works (receive
+ the expected callback).
+ """
+ dut = self.android_devices[0]
+ dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+ autils.fail_on_event(dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+
+ def test_attach_with_identity(self):
+ """Functional test case / Attach test cases / attach with identity callback
+
+ Validates that attaching to the Wi-Fi Aware service works (receive
+ the expected callbacks).
+ """
+ dut = self.android_devices[0]
+ dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+
+ def test_attach_multiple_sessions(self):
+ """Functional test case / Attach test cases / multiple attach sessions
+
+ Validates that when creating multiple attach sessions each can be
+ configured independently as to whether or not to receive an identity
+ callback.
+ """
+ dut = self.android_devices[0]
+
+ # Create 3 attach sessions: 2 without identity callback, 1 with
+ id1 = dut.droid.wifiAwareAttach(False, None, True)
+ time.sleep(10) # to make sure all calls and callbacks are done
+ id2 = dut.droid.wifiAwareAttach(True, None, True)
+ time.sleep(10) # to make sure all calls and callbacks are done
+ id3 = dut.droid.wifiAwareAttach(False, None, True)
+ dut.log.info('id1=%d, id2=%d, id3=%d', id1, id2, id3)
+
+ # Attach session 1: wait for attach, should not get identity
+ autils.wait_for_event(dut,
+ autils.decorate_event(aconsts.EVENT_CB_ON_ATTACHED,
+ id1))
+ autils.fail_on_event(dut,
+ autils.decorate_event(
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED, id1))
+
+ # Attach session 2: wait for attach and for identity callback
+ autils.wait_for_event(dut,
+ autils.decorate_event(aconsts.EVENT_CB_ON_ATTACHED,
+ id2))
+ autils.wait_for_event(dut,
+ autils.decorate_event(
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED, id2))
+
+ # Attach session 3: wait for attach, should not get identity
+ autils.wait_for_event(dut,
+ autils.decorate_event(aconsts.EVENT_CB_ON_ATTACHED,
+ id3))
+ autils.fail_on_event(dut,
+ autils.decorate_event(
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED, id3))
+
+ def test_attach_with_no_wifi(self):
+ """Function test case / Attach test cases / attempt to attach with wifi off
+
+ Validates that if trying to attach with Wi-Fi disabled will receive the
+ expected failure callback. As a side-effect also validates that the broadcast
+ for Aware unavailable is received.
+ """
+ dut = self.android_devices[0]
+ wutils.wifi_toggle_state(dut, False)
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACH_FAILED)
+
+ def test_attach_apm_toggle_attach_again(self):
+ """Validates that enabling Airplane mode while Aware is on resets it
+ correctly, and allows it to be re-enabled when Airplane mode is then
+ disabled."""
+ dut = self.android_devices[0]
+
+ # enable Aware (attach)
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # enable airplane mode
+ force_airplane_mode(dut, True)
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
+
+ # wait a few seconds and disable airplane mode
+ time.sleep(10)
+ force_airplane_mode(dut, False)
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
+
+ # try enabling Aware again (attach)
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
diff --git a/acts/tests/google/wifi/aware/functional/CapabilitiesTest.py b/acts/tests/google/wifi/aware/functional/CapabilitiesTest.py
new file mode 100644
index 0000000..55e63e9
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/CapabilitiesTest.py
@@ -0,0 +1,252 @@
+#!/usr/bin/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.
+
+from acts import asserts
+from acts import signals
+
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class CapabilitiesTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware Capabilities - verifying that the provided
+ capabilities are real (i.e. available)."""
+
+ SERVICE_NAME = "GoogleTestXYZ"
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def create_config(self, dtype, service_name):
+ """Create a discovery configuration based on input parameters.
+
+ Args:
+ dtype: Publish or Subscribe discovery type
+ service_name: Service name.
+
+ Returns:
+ Discovery configuration object.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = service_name
+ return config
+
+ def start_discovery_session(self, dut, session_id, is_publish, dtype,
+ service_name, expect_success):
+ """Start a discovery session
+
+ Args:
+ dut: Device under test
+ session_id: ID of the Aware session in which to start discovery
+ is_publish: True for a publish session, False for subscribe session
+ dtype: Type of the discovery session
+ service_name: Service name to use for the discovery session
+ expect_success: True if expect session to be created, False otherwise
+
+ Returns:
+ Discovery session ID.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = service_name
+
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_PUBLISH_STARTED
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED
+
+ if expect_success:
+ autils.wait_for_event(dut, event_name)
+ else:
+ autils.wait_for_event(dut, aconsts.SESSION_CB_ON_SESSION_CONFIG_FAILED)
+
+ return disc_id
+
+ ###############################
+
+ def test_max_discovery_sessions(self):
+ """Validate that the device can create as many discovery sessions as are
+ indicated in the device capabilities
+ """
+ dut = self.android_devices[0]
+
+ # attach
+ session_id = dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ service_name_template = 'GoogleTestService-%s-%d'
+
+ # start the max number of publish sessions
+ for i in range(dut.aware_capabilities[aconsts.CAP_MAX_PUBLISHES]):
+ # create publish discovery session of both types
+ pub_disc_id = self.start_discovery_session(
+ dut, session_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED
+ if i % 2 == 0 else aconsts.PUBLISH_TYPE_SOLICITED,
+ service_name_template % ('pub', i), True)
+
+ # start the max number of subscribe sessions
+ for i in range(dut.aware_capabilities[aconsts.CAP_MAX_SUBSCRIBES]):
+ # create publish discovery session of both types
+ sub_disc_id = self.start_discovery_session(
+ dut, session_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE
+ if i % 2 == 0 else aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ service_name_template % ('sub', i), True)
+
+ # start another publish & subscribe and expect failure
+ self.start_discovery_session(dut, session_id, True,
+ aconsts.PUBLISH_TYPE_UNSOLICITED,
+ service_name_template % ('pub', 900), False)
+ self.start_discovery_session(dut, session_id, False,
+ aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ service_name_template % ('pub', 901), False)
+
+ # delete one of the publishes and try again (see if can create subscribe
+ # instead - should not)
+ dut.droid.wifiAwareDestroyDiscoverySession(pub_disc_id)
+ self.start_discovery_session(dut, session_id, False,
+ aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ service_name_template % ('pub', 902), False)
+ self.start_discovery_session(dut, session_id, True,
+ aconsts.PUBLISH_TYPE_UNSOLICITED,
+ service_name_template % ('pub', 903), True)
+
+ # delete one of the subscribes and try again (see if can create publish
+ # instead - should not)
+ dut.droid.wifiAwareDestroyDiscoverySession(sub_disc_id)
+ self.start_discovery_session(dut, session_id, True,
+ aconsts.PUBLISH_TYPE_UNSOLICITED,
+ service_name_template % ('pub', 904), False)
+ self.start_discovery_session(dut, session_id, False,
+ aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ service_name_template % ('pub', 905), True)
+
+ def test_max_ndp(self):
+ """Validate that the device can create as many NDPs as are specified
+ by its capabilities.
+
+ Mechanics:
+ - Publisher on DUT (first device)
+ - Subscribers on all other devices
+ - On discovery set up NDP
+
+ Note: the test requires MAX_NDP + 2 devices to be validated. If these are
+ not available it will be skipped (not failed).
+ """
+ dut = self.android_devices[0]
+
+ # get max NDP: using first available device (assumes all devices are the
+ # same)
+ max_ndp = dut.aware_capabilities[aconsts.CAP_MAX_NDP_SESSIONS]
+
+ if len(self.android_devices) < max_ndp + 2:
+ raise signals.TestSkip('Setup does not contain a sufficient number of '
+ 'devices: need %d, have %d' % (max_ndp + 2,
+ len(self.android_devices)))
+
+ # attach
+ session_id = dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # start publisher
+ p_disc_id = self.start_discovery_session(
+ dut,
+ session_id,
+ is_publish=True,
+ dtype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ service_name=self.SERVICE_NAME,
+ expect_success=True)
+
+ # loop over other DUTs
+ for i in range(max_ndp + 1):
+ other_dut = self.android_devices[i + 1]
+
+ # attach
+ other_session_id = other_dut.droid.wifiAwareAttach()
+ autils.wait_for_event(other_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # start subscriber
+ s_disc_id = self.start_discovery_session(
+ other_dut,
+ other_session_id,
+ is_publish=False,
+ dtype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ service_name=self.SERVICE_NAME,
+ expect_success=True)
+
+ discovery_event = autils.wait_for_event(
+ other_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+ peer_id_on_sub = discovery_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ # Subscriber: send message to peer (Publisher - so it knows our address)
+ other_dut.droid.wifiAwareSendMessage(
+ s_disc_id, peer_id_on_sub,
+ self.get_next_msg_id(), "ping", aconsts.MAX_TX_RETRIES)
+ autils.wait_for_event(other_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
+
+ # Publisher: wait for received message
+ pub_rx_msg_event = autils.wait_for_event(
+ dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ peer_id_on_pub = pub_rx_msg_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ # publisher (responder): request network
+ p_req_key = autils.request_network(
+ dut,
+ dut.droid.wifiAwareCreateNetworkSpecifier(p_disc_id, peer_id_on_pub))
+
+ # subscriber (initiator): request network
+ s_req_key = autils.request_network(
+ other_dut,
+ other_dut.droid.wifiAwareCreateNetworkSpecifier(
+ s_disc_id, peer_id_on_sub))
+
+ # wait for network (or not - on the last iteration)
+ if i != max_ndp:
+ p_net_event = autils.wait_for_event_with_keys(
+ dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, p_req_key))
+ s_net_event = autils.wait_for_event_with_keys(
+ other_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, s_req_key))
+
+ p_aware_if = p_net_event['data'][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ s_aware_if = s_net_event['data'][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ self.log.info('Interface names: p=%s, s=%s', p_aware_if, s_aware_if)
+
+ p_ipv6 = dut.droid.connectivityGetLinkLocalIpv6Address(
+ p_aware_if).split('%')[0]
+ s_ipv6 = other_dut.droid.connectivityGetLinkLocalIpv6Address(
+ s_aware_if).split('%')[0]
+ self.log.info('Interface addresses (IPv6): p=%s, s=%s', p_ipv6, s_ipv6)
+ else:
+ autils.fail_on_event_with_keys(
+ dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, p_req_key))
+ autils.fail_on_event_with_keys(
+ other_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, s_req_key))
diff --git a/acts/tests/google/wifi/aware/functional/DataPathTest.py b/acts/tests/google/wifi/aware/functional/DataPathTest.py
new file mode 100644
index 0000000..8414c1d
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/DataPathTest.py
@@ -0,0 +1,729 @@
+#!/usr/bin/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 time
+
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class DataPathTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware data-path."""
+
+ # configuration parameters used by tests
+ ENCR_TYPE_OPEN = 0
+ ENCR_TYPE_PASSPHRASE = 1
+ ENCR_TYPE_PMK = 2
+
+ PASSPHRASE = "This is some random passphrase - very very secure!!"
+ PASSPHRASE_MIN = "01234567"
+ PASSPHRASE_MAX = "012345678901234567890123456789012345678901234567890123456789012"
+ PMK = "ODU0YjE3YzdmNDJiNWI4NTQ2NDJjNDI3M2VkZTQyZGU="
+ PASSPHRASE2 = "This is some random passphrase - very very secure - but diff!!"
+ PMK2 = "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI="
+
+ PING_MSG = "ping"
+
+ # message re-transmit counter (increases reliability in open-environment)
+ # Note: reliability of message transmission is tested elsewhere
+ MSG_RETX_COUNT = 5 # hard-coded max value, internal API
+
+ # number of second to 'reasonably' wait to make sure that devices synchronize
+ # with each other - useful for OOB test cases, where the OOB discovery would
+ # take some time
+ WAIT_FOR_CLUSTER = 5
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def create_config(self, dtype):
+ """Create a base configuration based on input parameters.
+
+ Args:
+ dtype: Publish or Subscribe discovery type
+
+ Returns:
+ Discovery configuration object.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "GoogleTestServiceDataPath"
+ return config
+
+ def request_network(self, dut, ns):
+ """Request a Wi-Fi Aware network.
+
+ Args:
+ dut: Device
+ ns: Network specifier
+ Returns: the request key
+ """
+ network_req = {"TransportType": 5, "NetworkSpecifier": ns}
+ return dut.droid.connectivityRequestWifiAwareNetwork(network_req)
+
+ def set_up_discovery(self, ptype, stype, get_peer_id):
+ """Set up discovery sessions and wait for service discovery.
+
+ Args:
+ ptype: Publish discovery type
+ stype: Subscribe discovery type
+ get_peer_id: Send a message across to get the peer's id
+ """
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach()
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach()
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Publisher: start publish and wait for confirmation
+ p_disc_id = p_dut.droid.wifiAwarePublish(p_id, self.create_config(ptype))
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_disc_id = s_dut.droid.wifiAwareSubscribe(s_id, self.create_config(stype))
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
+
+ # Subscriber: wait for service discovery
+ discovery_event = autils.wait_for_event(
+ s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+ peer_id_on_sub = discovery_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ peer_id_on_pub = None
+ if get_peer_id: # only need message to receive peer ID
+ # Subscriber: send message to peer (Publisher - so it knows our address)
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub,
+ self.get_next_msg_id(), self.PING_MSG,
+ self.MSG_RETX_COUNT)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
+
+ # Publisher: wait for received message
+ pub_rx_msg_event = autils.wait_for_event(
+ p_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ peer_id_on_pub = pub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ return (p_dut, s_dut, p_id, s_id, p_disc_id, s_disc_id, peer_id_on_sub,
+ peer_id_on_pub)
+
+ def run_ib_data_path_test(self,
+ ptype,
+ stype,
+ encr_type,
+ use_peer_id,
+ passphrase_to_use=None):
+ """Runs the in-band data-path tests.
+
+ Args:
+ ptype: Publish discovery type
+ stype: Subscribe discovery type
+ encr_type: Encryption type, one of ENCR_TYPE_*
+ use_peer_id: On Responder (publisher): True to use peer ID, False to
+ accept any request
+ passphrase_to_use: The passphrase to use if encr_type=ENCR_TYPE_PASSPHRASE
+ If None then use self.PASSPHRASE
+ """
+ (p_dut, s_dut, p_id, s_id, p_disc_id, s_disc_id, peer_id_on_sub,
+ peer_id_on_pub) = self.set_up_discovery(ptype, stype, use_peer_id)
+
+ passphrase = None
+ pmk = None
+ if encr_type == self.ENCR_TYPE_PASSPHRASE:
+ passphrase = self.PASSPHRASE if passphrase_to_use == None else passphrase_to_use
+ elif encr_type == self.ENCR_TYPE_PMK:
+ pmk = self.PMK
+
+ # Publisher: request network
+ p_req_key = self.request_network(
+ p_dut,
+ p_dut.droid.wifiAwareCreateNetworkSpecifier(p_disc_id, peer_id_on_pub if
+ use_peer_id else None, passphrase, pmk))
+
+ # Subscriber: request network
+ s_req_key = self.request_network(
+ s_dut,
+ s_dut.droid.wifiAwareCreateNetworkSpecifier(s_disc_id, peer_id_on_sub,
+ passphrase, pmk))
+
+ # Publisher & Subscriber: wait for network formation
+ p_net_event = autils.wait_for_event_with_keys(
+ p_dut, cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, p_req_key))
+ s_net_event = autils.wait_for_event_with_keys(
+ s_dut, cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, s_req_key))
+
+ p_aware_if = p_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ s_aware_if = s_net_event["data"][cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ self.log.info("Interface names: p=%s, s=%s", p_aware_if, s_aware_if)
+
+ p_ipv6 = p_dut.droid.connectivityGetLinkLocalIpv6Address(p_aware_if).split(
+ "%")[0]
+ s_ipv6 = s_dut.droid.connectivityGetLinkLocalIpv6Address(s_aware_if).split(
+ "%")[0]
+ self.log.info("Interface addresses (IPv6): p=%s, s=%s", p_ipv6, s_ipv6)
+
+ # TODO: possibly send messages back and forth, prefer to use netcat/nc
+
+ # terminate sessions and wait for ON_LOST callbacks
+ p_dut.droid.wifiAwareDestroy(p_id)
+ s_dut.droid.wifiAwareDestroy(s_id)
+
+ autils.wait_for_event_with_keys(
+ p_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LOST), (cconsts.NETWORK_CB_KEY_ID, p_req_key))
+ autils.wait_for_event_with_keys(
+ s_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LOST), (cconsts.NETWORK_CB_KEY_ID, s_req_key))
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ def run_oob_data_path_test(self, encr_type, use_peer_id):
+ """Runs the out-of-band data-path tests.
+
+ Args:
+ encr_type: Encryption type, one of ENCR_TYPE_*
+ use_peer_id: On Responder: True to use peer ID, False to accept any
+ request
+ """
+ init_dut = self.android_devices[0]
+ init_dut.pretty_name = "Initiator"
+ resp_dut = self.android_devices[1]
+ resp_dut.pretty_name = "Responder"
+
+ # Initiator+Responder: attach and wait for confirmation & identity
+ init_id = init_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ init_ident_event = autils.wait_for_event(
+ init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ init_mac = init_ident_event["data"]["mac"]
+ time.sleep(self.device_startup_offset)
+ resp_id = resp_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ resp_ident_event = autils.wait_for_event(
+ resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ resp_mac = resp_ident_event["data"]["mac"]
+
+ # wait for for devices to synchronize with each other - there are no other
+ # mechanisms to make sure this happens for OOB discovery (except retrying
+ # to execute the data-path request)
+ time.sleep(self.WAIT_FOR_CLUSTER)
+
+ passphrase = None
+ pmk = None
+ if encr_type == self.ENCR_TYPE_PASSPHRASE:
+ passphrase = self.PASSPHRASE
+ elif encr_type == self.ENCR_TYPE_PMK:
+ pmk = self.PMK
+
+ # Responder: request network
+ resp_req_key = self.request_network(
+ resp_dut,
+ resp_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ resp_id, aconsts.DATA_PATH_RESPONDER, init_mac
+ if use_peer_id else None, passphrase, pmk))
+
+ # Initiator: request network
+ init_req_key = self.request_network(
+ init_dut,
+ init_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, passphrase, pmk))
+
+ # Initiator & Responder: wait for network formation
+ init_net_event = autils.wait_for_event_with_keys(
+ init_dut, cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, init_req_key))
+ resp_net_event = autils.wait_for_event_with_keys(
+ resp_dut, cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED),
+ (cconsts.NETWORK_CB_KEY_ID, resp_req_key))
+
+ init_aware_if = init_net_event["data"][
+ cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ resp_aware_if = resp_net_event["data"][
+ cconsts.NETWORK_CB_KEY_INTERFACE_NAME]
+ self.log.info("Interface names: I=%s, R=%s", init_aware_if, resp_aware_if)
+
+ init_ipv6 = init_dut.droid.connectivityGetLinkLocalIpv6Address(
+ init_aware_if).split("%")[0]
+ resp_ipv6 = resp_dut.droid.connectivityGetLinkLocalIpv6Address(
+ resp_aware_if).split("%")[0]
+ self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
+ resp_ipv6)
+
+ # TODO: possibly send messages back and forth, prefer to use netcat/nc
+
+ # terminate sessions and wait for ON_LOST callbacks
+ init_dut.droid.wifiAwareDestroy(init_id)
+ resp_dut.droid.wifiAwareDestroy(resp_id)
+
+ autils.wait_for_event_with_keys(
+ init_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LOST), (cconsts.NETWORK_CB_KEY_ID, init_req_key))
+ autils.wait_for_event_with_keys(
+ resp_dut, cconsts.EVENT_NETWORK_CALLBACK, autils.EVENT_NDP_TIMEOUT,
+ (cconsts.NETWORK_CB_KEY_EVENT,
+ cconsts.NETWORK_CB_LOST), (cconsts.NETWORK_CB_KEY_ID, resp_req_key))
+
+ # clean-up
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+
+ def run_mismatched_ib_data_path_test(self, pub_mismatch, sub_mismatch):
+ """Runs the negative in-band data-path tests: mismatched peer ID.
+
+ Args:
+ pub_mismatch: Mismatch the publisher's ID
+ sub_mismatch: Mismatch the subscriber's ID
+ """
+ (p_dut, s_dut, p_id, s_id, p_disc_id, s_disc_id,
+ peer_id_on_sub, peer_id_on_pub) = self.set_up_discovery(
+ aconsts.PUBLISH_TYPE_UNSOLICITED, aconsts.SUBSCRIBE_TYPE_PASSIVE, True)
+
+ if pub_mismatch:
+ peer_id_on_pub = peer_id_on_pub -1
+ if sub_mismatch:
+ peer_id_on_sub = peer_id_on_sub - 1
+
+ # Publisher: request network
+ p_req_key = self.request_network(
+ p_dut,
+ p_dut.droid.wifiAwareCreateNetworkSpecifier(p_disc_id, peer_id_on_pub,
+ None))
+
+ # Subscriber: request network
+ s_req_key = self.request_network(
+ s_dut,
+ s_dut.droid.wifiAwareCreateNetworkSpecifier(s_disc_id, peer_id_on_sub,
+ None))
+
+ # Publisher & Subscriber: fail on network formation
+ time.sleep(autils.EVENT_NDP_TIMEOUT)
+ autils.fail_on_event(p_dut, cconsts.EVENT_NETWORK_CALLBACK, timeout=0)
+ autils.fail_on_event(s_dut, cconsts.EVENT_NETWORK_CALLBACK, timeout=0)
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ def run_mismatched_oob_data_path_test(self,
+ init_mismatch_mac=False,
+ resp_mismatch_mac=False,
+ init_encr_type=ENCR_TYPE_OPEN,
+ resp_encr_type=ENCR_TYPE_OPEN):
+ """Runs the negative out-of-band data-path tests: mismatched information
+ between Responder and Initiator.
+
+ Args:
+ init_mismatch_mac: True to mismatch the Initiator MAC address
+ resp_mismatch_mac: True to mismatch the Responder MAC address
+ init_encr_type: Encryption type of Initiator - ENCR_TYPE_*
+ resp_encr_type: Encryption type of Responder - ENCR_TYPE_*
+ """
+ init_dut = self.android_devices[0]
+ init_dut.pretty_name = "Initiator"
+ resp_dut = self.android_devices[1]
+ resp_dut.pretty_name = "Responder"
+
+ # Initiator+Responder: attach and wait for confirmation & identity
+ init_id = init_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ init_ident_event = autils.wait_for_event(
+ init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ init_mac = init_ident_event["data"]["mac"]
+ time.sleep(self.device_startup_offset)
+ resp_id = resp_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ resp_ident_event = autils.wait_for_event(
+ resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ resp_mac = resp_ident_event["data"]["mac"]
+
+ if init_mismatch_mac: # assumes legit ones don't start with "00"
+ init_mac = "00" + init_mac[2:]
+ if resp_mismatch_mac:
+ resp_mac = "00" + resp_mac[2:]
+
+ # wait for for devices to synchronize with each other - there are no other
+ # mechanisms to make sure this happens for OOB discovery (except retrying
+ # to execute the data-path request)
+ time.sleep(self.WAIT_FOR_CLUSTER)
+
+ # set up separate keys: even if types are the same we want a mismatch
+ init_passphrase = None
+ init_pmk = None
+ if init_encr_type == self.ENCR_TYPE_PASSPHRASE:
+ init_passphrase = self.PASSPHRASE
+ elif init_encr_type == self.ENCR_TYPE_PMK:
+ init_pmk = self.PMK
+
+ resp_passphrase = None
+ resp_pmk = None
+ if resp_encr_type == self.ENCR_TYPE_PASSPHRASE:
+ resp_passphrase = self.PASSPHRASE2
+ elif resp_encr_type == self.ENCR_TYPE_PMK:
+ resp_pmk = self.PMK2
+
+ # Responder: request network
+ resp_req_key = self.request_network(
+ resp_dut,
+ resp_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, resp_passphrase,
+ resp_pmk))
+
+ # Initiator: request network
+ init_req_key = self.request_network(
+ init_dut,
+ init_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, init_passphrase,
+ init_pmk))
+
+ # Initiator & Responder: fail on network formation
+ time.sleep(autils.EVENT_NDP_TIMEOUT)
+ autils.fail_on_event(init_dut, cconsts.EVENT_NETWORK_CALLBACK, timeout=0)
+ autils.fail_on_event(resp_dut, cconsts.EVENT_NETWORK_CALLBACK, timeout=0)
+
+ # clean-up
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+
+
+ #######################################
+ # Positive In-Band (IB) tests key:
+ #
+ # names is: test_ib_<pub_type>_<sub_type>_<encr_type>_<peer_spec>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ # encr_type: Encription type: open, passphrase
+ # peer_spec: Peer specification method: any or specific
+ #
+ # Note: In-Band means using Wi-Fi Aware for discovery and referring to the
+ # peer using the Aware-provided peer handle (as opposed to a MAC address).
+ #######################################
+
+ def test_ib_unsolicited_passive_open_specific(self):
+ """Data-path: in-band, unsolicited/passive, open encryption, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=True)
+
+ def test_ib_unsolicited_passive_open_any(self):
+ """Data-path: in-band, unsolicited/passive, open encryption, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=False)
+
+ def test_ib_unsolicited_passive_passphrase_specific(self):
+ """Data-path: in-band, unsolicited/passive, passphrase, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=True)
+
+ def test_ib_unsolicited_passive_passphrase_any(self):
+ """Data-path: in-band, unsolicited/passive, passphrase, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=False)
+
+ def test_ib_unsolicited_passive_pmk_specific(self):
+ """Data-path: in-band, unsolicited/passive, PMK, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=True)
+
+ def test_ib_unsolicited_passive_pmk_any(self):
+ """Data-path: in-band, unsolicited/passive, PMK, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=False)
+
+ def test_ib_solicited_active_open_specific(self):
+ """Data-path: in-band, solicited/active, open encryption, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=True)
+
+ def test_ib_solicited_active_open_any(self):
+ """Data-path: in-band, solicited/active, open encryption, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=False)
+
+ def test_ib_solicited_active_passphrase_specific(self):
+ """Data-path: in-band, solicited/active, passphrase, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=True)
+
+ def test_ib_solicited_active_passphrase_any(self):
+ """Data-path: in-band, solicited/active, passphrase, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=False)
+
+ def test_ib_solicited_active_pmk_specific(self):
+ """Data-path: in-band, solicited/active, PMK, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=True)
+
+ def test_ib_solicited_active_pmk_any(self):
+ """Data-path: in-band, solicited/active, PMK, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_ib_data_path_test(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=False)
+
+ #######################################
+ # Positive Out-of-Band (OOB) tests key:
+ #
+ # names is: test_oob_<encr_type>_<peer_spec>
+ # where:
+ #
+ # encr_type: Encription type: open, passphrase
+ # peer_spec: Peer specification method: any or specific
+ #
+ # Note: Out-of-Band means using a non-Wi-Fi Aware mechanism for discovery and
+ # exchange of MAC addresses and then Wi-Fi Aware for data-path.
+ #######################################
+
+ def test_oob_open_specific(self):
+ """Data-path: out-of-band, open encryption, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=True)
+
+ def test_oob_open_any(self):
+ """Data-path: out-of-band, open encryption, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_OPEN,
+ use_peer_id=False)
+
+ def test_oob_passphrase_specific(self):
+ """Data-path: out-of-band, passphrase, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=True)
+
+ def test_oob_passphrase_any(self):
+ """Data-path: out-of-band, passphrase, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=False)
+
+ def test_oob_pmk_specific(self):
+ """Data-path: out-of-band, PMK, specific peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=True)
+
+ def test_oob_pmk_any(self):
+ """Data-path: out-of-band, PMK, any peer
+
+ Verifies end-to-end discovery + data-path creation.
+ """
+ self.run_oob_data_path_test(
+ encr_type=self.ENCR_TYPE_PMK,
+ use_peer_id=False)
+
+ ##############################################################
+
+ def test_passphrase_min(self):
+ """Data-path: minimum passphrase length
+
+ Use in-band, unsolicited/passive, any peer combination
+ """
+ self.run_ib_data_path_test(ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=False,
+ passphrase_to_use=self.PASSPHRASE_MIN)
+
+ def test_passphrase_max(self):
+ """Data-path: maximum passphrase length
+
+ Use in-band, unsolicited/passive, any peer combination
+ """
+ self.run_ib_data_path_test(ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ encr_type=self.ENCR_TYPE_PASSPHRASE,
+ use_peer_id=False,
+ passphrase_to_use=self.PASSPHRASE_MAX)
+
+ def test_negative_mismatch_publisher_peer_id(self):
+ """Data-path: failure when publisher peer ID is mismatched"""
+ self.run_mismatched_ib_data_path_test(pub_mismatch=True, sub_mismatch=False)
+
+ def test_negative_mismatch_subscriber_peer_id(self):
+ """Data-path: failure when subscriber peer ID is mismatched"""
+ self.run_mismatched_ib_data_path_test(pub_mismatch=False, sub_mismatch=True)
+
+ def test_negative_mismatch_init_mac(self):
+ """Data-path: failure when Initiator MAC address mismatch"""
+ self.run_mismatched_oob_data_path_test(
+ init_mismatch_mac=True,
+ resp_mismatch_mac=False)
+
+ def test_negative_mismatch_resp_mac(self):
+ """Data-path: failure when Responder MAC address mismatch"""
+ self.run_mismatched_oob_data_path_test(
+ init_mismatch_mac=False,
+ resp_mismatch_mac=True)
+
+ def test_negative_mismatch_passphrase(self):
+ """Data-path: failure when passphrases mismatch"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PASSPHRASE,
+ resp_encr_type=self.ENCR_TYPE_PASSPHRASE)
+
+ def test_negative_mismatch_pmk(self):
+ """Data-path: failure when PMK mismatch"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PMK,
+ resp_encr_type=self.ENCR_TYPE_PMK)
+
+ def test_negative_mismatch_open_passphrase(self):
+ """Data-path: failure when initiator is open, and responder passphrase"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_OPEN,
+ resp_encr_type=self.ENCR_TYPE_PASSPHRASE)
+
+ def test_negative_mismatch_open_pmk(self):
+ """Data-path: failure when initiator is open, and responder PMK"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_OPEN,
+ resp_encr_type=self.ENCR_TYPE_PMK)
+
+ def test_negative_mismatch_pmk_passphrase(self):
+ """Data-path: failure when initiator is pmk, and responder passphrase"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PMK,
+ resp_encr_type=self.ENCR_TYPE_PASSPHRASE)
+
+ def test_negative_mismatch_passphrase_open(self):
+ """Data-path: failure when initiator is passphrase, and responder open"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PASSPHRASE,
+ resp_encr_type=self.ENCR_TYPE_OPEN)
+
+ def test_negative_mismatch_pmk_open(self):
+ """Data-path: failure when initiator is PMK, and responder open"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PMK,
+ resp_encr_type=self.ENCR_TYPE_OPEN)
+
+ def test_negative_mismatch_passphrase_pmk(self):
+ """Data-path: failure when initiator is passphrase, and responder pmk"""
+ self.run_mismatched_oob_data_path_test(
+ init_encr_type=self.ENCR_TYPE_PASSPHRASE,
+ resp_encr_type=self.ENCR_TYPE_OPEN)
diff --git a/acts/tests/google/wifi/aware/functional/DiscoveryTest.py b/acts/tests/google/wifi/aware/functional/DiscoveryTest.py
new file mode 100644
index 0000000..a1ace3e
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/DiscoveryTest.py
@@ -0,0 +1,811 @@
+#!/usr/bin/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 string
+import time
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class DiscoveryTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware discovery."""
+
+ # configuration parameters used by tests
+ PAYLOAD_SIZE_MIN = 0
+ PAYLOAD_SIZE_TYPICAL = 1
+ PAYLOAD_SIZE_MAX = 2
+
+ # message strings
+ query_msg = "How are you doing? 你好嗎？"
+ response_msg = "Doing ok - thanks! 做的不錯 - 謝謝！"
+
+ # message re-transmit counter (increases reliability in open-environment)
+ # Note: reliability of message transmission is tested elsewhere
+ msg_retx_count = 5 # hard-coded max value, internal API
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def create_base_config(self, caps, is_publish, ptype, stype, payload_size,
+ ttl, term_ind_on, null_match):
+ """Create a base configuration based on input parameters.
+
+ Args:
+ caps: device capability dictionary
+ is_publish: True if a publish config, else False
+ ptype: unsolicited or solicited (used if is_publish is True)
+ stype: passive or active (used if is_publish is False)
+ payload_size: min, typical, max (PAYLOAD_SIZE_xx)
+ ttl: time-to-live configuration (0 - forever)
+ term_ind_on: is termination indication enabled
+ null_match: null-out the middle match filter
+ Returns:
+ publish discovery configuration object.
+ """
+ config = {}
+ if is_publish:
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = ptype
+ else:
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = stype
+ config[aconsts.DISCOVERY_KEY_TTL] = ttl
+ config[aconsts.DISCOVERY_KEY_TERM_CB_ENABLED] = term_ind_on
+ if payload_size == self.PAYLOAD_SIZE_MIN:
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "a"
+ config[aconsts.DISCOVERY_KEY_SSI] = None
+ config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = []
+ elif payload_size == self.PAYLOAD_SIZE_TYPICAL:
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "GoogleTestServiceX"
+ if is_publish:
+ config[aconsts.DISCOVERY_KEY_SSI] = string.ascii_letters
+ else:
+ config[aconsts.DISCOVERY_KEY_SSI] = string.ascii_letters[::
+ -1] # reverse
+ config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = autils.encode_list(
+ [(10).to_bytes(1, byteorder="big"), "hello there string"
+ if not null_match else None,
+ bytes(range(40))])
+ else: # PAYLOAD_SIZE_MAX
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "VeryLong" + "X" * (
+ caps[aconsts.CAP_MAX_SERVICE_NAME_LEN] - 8)
+ config[aconsts.DISCOVERY_KEY_SSI] = ("P" if is_publish else "S") * caps[
+ aconsts.CAP_MAX_SERVICE_SPECIFIC_INFO_LEN]
+ mf = autils.construct_max_match_filter(
+ caps[aconsts.CAP_MAX_MATCH_FILTER_LEN])
+ if null_match:
+ mf[2] = None
+ config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = autils.encode_list(mf)
+
+ return config
+
+ def create_publish_config(self, caps, ptype, payload_size, ttl, term_ind_on,
+ null_match):
+ """Create a publish configuration based on input parameters.
+
+ Args:
+ caps: device capability dictionary
+ ptype: unsolicited or solicited
+ payload_size: min, typical, max (PAYLOAD_SIZE_xx)
+ ttl: time-to-live configuration (0 - forever)
+ term_ind_on: is termination indication enabled
+ null_match: null-out the middle match filter
+ Returns:
+ publish discovery configuration object.
+ """
+ return self.create_base_config(caps, True, ptype, None, payload_size, ttl,
+ term_ind_on, null_match)
+
+ def create_subscribe_config(self, caps, stype, payload_size, ttl, term_ind_on,
+ null_match):
+ """Create a subscribe configuration based on input parameters.
+
+ Args:
+ caps: device capability dictionary
+ stype: passive or active
+ payload_size: min, typical, max (PAYLOAD_SIZE_xx)
+ ttl: time-to-live configuration (0 - forever)
+ term_ind_on: is termination indication enabled
+ null_match: null-out the middle match filter
+ Returns:
+ subscribe discovery configuration object.
+ """
+ return self.create_base_config(caps, False, None, stype, payload_size, ttl,
+ term_ind_on, null_match)
+
+ def positive_discovery_test_utility(self, ptype, stype, payload_size):
+ """Utility which runs a positive discovery test:
+ - Discovery (publish/subscribe) with TTL=0 (non-self-terminating)
+ - Exchange messages
+ - Update publish/subscribe
+ - Terminate
+
+ Args:
+ ptype: Publish discovery type
+ stype: Subscribe discovery type
+ payload_size: One of PAYLOAD_SIZE_* constants - MIN, TYPICAL, MAX
+ """
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Publisher: start publish and wait for confirmation
+ p_config = self.create_publish_config(
+ p_dut.aware_capabilities,
+ ptype,
+ payload_size,
+ ttl=0,
+ term_ind_on=False,
+ null_match=False)
+ p_disc_id = p_dut.droid.wifiAwarePublish(p_id, p_config)
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_config = self.create_subscribe_config(
+ s_dut.aware_capabilities,
+ stype,
+ payload_size,
+ ttl=0,
+ term_ind_on=False,
+ null_match=True)
+ s_disc_id = s_dut.droid.wifiAwareSubscribe(s_id, s_config)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
+
+ # Subscriber: wait for service discovery
+ discovery_event = autils.wait_for_event(
+ s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+ peer_id_on_sub = discovery_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ # Subscriber: validate contents of discovery:
+ # - SSI: publisher's
+ # - Match filter: UNSOLICITED - publisher, SOLICITED - subscriber
+ autils.assert_equal_strings(
+ bytes(discovery_event["data"][
+ aconsts.SESSION_CB_KEY_SERVICE_SPECIFIC_INFO]).decode("utf-8"),
+ p_config[aconsts.DISCOVERY_KEY_SSI],
+ "Discovery mismatch: service specific info (SSI)")
+ asserts.assert_equal(
+ autils.decode_list(
+ discovery_event["data"][aconsts.SESSION_CB_KEY_MATCH_FILTER_LIST]),
+ autils.decode_list(p_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST]
+ if ptype == aconsts.PUBLISH_TYPE_UNSOLICITED else
+ s_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST]),
+ "Discovery mismatch: match filter")
+
+ # Subscriber: send message to peer (Publisher)
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub,
+ self.get_next_msg_id(), self.query_msg,
+ self.msg_retx_count)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
+
+ # Publisher: wait for received message
+ pub_rx_msg_event = autils.wait_for_event(
+ p_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ peer_id_on_pub = pub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ # Publisher: validate contents of message
+ asserts.assert_equal(
+ pub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING],
+ self.query_msg, "Subscriber -> Publisher message corrupted")
+
+ # Publisher: send message to peer (Subscriber)
+ p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub,
+ self.get_next_msg_id(), self.response_msg,
+ self.msg_retx_count)
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
+
+ # Subscriber: wait for received message
+ sub_rx_msg_event = autils.wait_for_event(
+ s_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+
+ # Subscriber: validate contents of message
+ asserts.assert_equal(
+ sub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_PEER_ID],
+ peer_id_on_sub,
+ "Subscriber received message from different peer ID then discovery!?")
+ autils.assert_equal_strings(
+ sub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING],
+ self.response_msg, "Publisher -> Subscriber message corrupted")
+
+ # Subscriber: validate that we're not getting another Service Discovery
+ autils.fail_on_event(s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+
+ # Publisher: update publish and wait for confirmation
+ p_config[aconsts.DISCOVERY_KEY_SSI] = "something else"
+ p_dut.droid.wifiAwareUpdatePublish(p_disc_id, p_config)
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED)
+
+ # Subscriber: expect a new service discovery
+ discovery_event = autils.wait_for_event(
+ s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+
+ # Subscriber: validate contents of discovery
+ autils.assert_equal_strings(
+ bytes(discovery_event["data"][
+ aconsts.SESSION_CB_KEY_SERVICE_SPECIFIC_INFO]).decode("utf-8"),
+ p_config[aconsts.DISCOVERY_KEY_SSI],
+ "Discovery mismatch (after pub update): service specific info (SSI)")
+ asserts.assert_equal(
+ autils.decode_list(
+ discovery_event["data"][aconsts.SESSION_CB_KEY_MATCH_FILTER_LIST]),
+ autils.decode_list(p_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST]
+ if ptype == aconsts.PUBLISH_TYPE_UNSOLICITED else
+ s_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST]),
+ "Discovery mismatch: match filter")
+
+ # Subscribe: update subscribe and wait for confirmation
+ s_config = self.create_subscribe_config(
+ s_dut.aware_capabilities,
+ stype,
+ payload_size,
+ ttl=0,
+ term_ind_on=False,
+ null_match=False)
+ s_dut.droid.wifiAwareUpdateSubscribe(s_disc_id, s_config)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED)
+
+ # Publisher+Subscriber: Terminate sessions
+ p_dut.droid.wifiAwareDestroyDiscoverySession(p_disc_id)
+ s_dut.droid.wifiAwareDestroyDiscoverySession(s_disc_id)
+
+ # sleep for timeout period and then verify all 'fail_on_event' together
+ time.sleep(autils.EVENT_TIMEOUT)
+
+ # verify that there were no other events
+ autils.verify_no_more_events(p_dut, timeout=0)
+ autils.verify_no_more_events(s_dut, timeout=0)
+
+ # verify that forbidden callbacks aren't called
+ autils.validate_forbidden_callbacks(p_dut, {aconsts.CB_EV_MATCH: 0})
+
+ def verify_discovery_session_term(self, dut, disc_id, config, is_publish,
+ term_ind_on):
+ """Utility to verify that the specified discovery session has terminated (by
+ waiting for the TTL and then attempting to reconfigure).
+
+ Args:
+ dut: device under test
+ disc_id: discovery id for the existing session
+ config: configuration of the existing session
+ is_publish: True if the configuration was publish, False if subscribe
+ term_ind_on: True if a termination indication is expected, False otherwise
+ """
+ # Wait for session termination
+ if term_ind_on:
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_TERMINATED,
+ disc_id))
+ else:
+ # can't defer wait to end since in any case have to wait for session to
+ # expire
+ autils.fail_on_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_TERMINATED,
+ disc_id))
+
+ # Validate that session expired by trying to configure it (expect failure)
+ config[aconsts.DISCOVERY_KEY_SSI] = "something else"
+ if is_publish:
+ dut.droid.wifiAwareUpdatePublish(disc_id, config)
+ else:
+ dut.droid.wifiAwareUpdateSubscribe(disc_id, config)
+
+ # The response to update discovery session is:
+ # term_ind_on=True: session was cleaned-up so won't get an explicit failure, but won't get a
+ # success either. Can check for no SESSION_CB_ON_SESSION_CONFIG_UPDATED but
+ # will defer to the end of the test (no events on queue).
+ # term_ind_on=False: session was not cleaned-up (yet). So expect
+ # SESSION_CB_ON_SESSION_CONFIG_FAILED.
+ if not term_ind_on:
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_CONFIG_FAILED,
+ disc_id))
+
+ def positive_ttl_test_utility(self, is_publish, ptype, stype, term_ind_on):
+ """Utility which runs a positive discovery session TTL configuration test
+
+ Iteration 1: Verify session started with TTL
+ Iteration 2: Verify session started without TTL and reconfigured with TTL
+ Iteration 3: Verify session started with (long) TTL and reconfigured with
+ (short) TTL
+
+ Args:
+ is_publish: True if testing publish, False if testing subscribe
+ ptype: Publish discovery type (used if is_publish is True)
+ stype: Subscribe discovery type (used if is_publish is False)
+ term_ind_on: Configuration of termination indication
+ """
+ SHORT_TTL = 5 # 5 seconds
+ LONG_TTL = 100 # 100 seconds
+ dut = self.android_devices[0]
+
+ # Attach and wait for confirmation
+ id = dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Iteration 1: Start discovery session with TTL
+ config = self.create_base_config(dut.aware_capabilities, is_publish, ptype,
+ stype, self.PAYLOAD_SIZE_TYPICAL,
+ SHORT_TTL, term_ind_on, False)
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(id, config, True)
+ autils.wait_for_event(dut,
+ autils.decorate_event(
+ aconsts.SESSION_CB_ON_PUBLISH_STARTED, disc_id))
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(id, config, True)
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED,
+ disc_id))
+
+ # Wait for session termination & verify
+ self.verify_discovery_session_term(dut, disc_id, config, is_publish,
+ term_ind_on)
+
+ # Iteration 2: Start a discovery session without TTL
+ config = self.create_base_config(dut.aware_capabilities, is_publish, ptype,
+ stype, self.PAYLOAD_SIZE_TYPICAL, 0,
+ term_ind_on, False)
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(id, config, True)
+ autils.wait_for_event(dut,
+ autils.decorate_event(
+ aconsts.SESSION_CB_ON_PUBLISH_STARTED, disc_id))
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(id, config, True)
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED,
+ disc_id))
+
+ # Update with a TTL
+ config = self.create_base_config(dut.aware_capabilities, is_publish, ptype,
+ stype, self.PAYLOAD_SIZE_TYPICAL,
+ SHORT_TTL, term_ind_on, False)
+ if is_publish:
+ dut.droid.wifiAwareUpdatePublish(disc_id, config)
+ else:
+ dut.droid.wifiAwareUpdateSubscribe(disc_id, config)
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED,
+ disc_id))
+
+ # Wait for session termination & verify
+ self.verify_discovery_session_term(dut, disc_id, config, is_publish,
+ term_ind_on)
+
+ # Iteration 3: Start a discovery session with (long) TTL
+ config = self.create_base_config(dut.aware_capabilities, is_publish, ptype,
+ stype, self.PAYLOAD_SIZE_TYPICAL, LONG_TTL,
+ term_ind_on, False)
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(id, config, True)
+ autils.wait_for_event(dut,
+ autils.decorate_event(
+ aconsts.SESSION_CB_ON_PUBLISH_STARTED, disc_id))
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(id, config, True)
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED,
+ disc_id))
+
+ # Update with a TTL
+ config = self.create_base_config(dut.aware_capabilities, is_publish, ptype,
+ stype, self.PAYLOAD_SIZE_TYPICAL,
+ SHORT_TTL, term_ind_on, False)
+ if is_publish:
+ dut.droid.wifiAwareUpdatePublish(disc_id, config)
+ else:
+ dut.droid.wifiAwareUpdateSubscribe(disc_id, config)
+ autils.wait_for_event(
+ dut,
+ autils.decorate_event(aconsts.SESSION_CB_ON_SESSION_CONFIG_UPDATED,
+ disc_id))
+
+ # Wait for session termination & verify
+ self.verify_discovery_session_term(dut, disc_id, config, is_publish,
+ term_ind_on)
+
+ # verify that there were no other events
+ autils.verify_no_more_events(dut)
+
+ # verify that forbidden callbacks aren't called
+ if not term_ind_on:
+ autils.validate_forbidden_callbacks(dut, {
+ aconsts.CB_EV_PUBLISH_TERMINATED: 0,
+ aconsts.CB_EV_SUBSCRIBE_TERMINATED: 0
+ })
+
+ def discovery_mismatch_test_utility(self,
+ is_expected_to_pass,
+ p_type,
+ s_type,
+ p_service_name=None,
+ s_service_name=None,
+ p_mf_1=None,
+ s_mf_1=None):
+ """Utility which runs the negative discovery test for mismatched service
+ configs.
+
+ Args:
+ is_expected_to_pass: True if positive test, False if negative
+ p_type: Publish discovery type
+ s_type: Subscribe discovery type
+ p_service_name: Publish service name (or None to leave unchanged)
+ s_service_name: Subscribe service name (or None to leave unchanged)
+ p_mf_1: Publish match filter element [1] (or None to leave unchanged)
+ s_mf_1: Subscribe match filter element [1] (or None to leave unchanged)
+ """
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # create configurations
+ p_config = self.create_publish_config(
+ p_dut.aware_capabilities,
+ p_type,
+ self.PAYLOAD_SIZE_TYPICAL,
+ ttl=0,
+ term_ind_on=False,
+ null_match=False)
+ if p_service_name is not None:
+ p_config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = p_service_name
+ if p_mf_1 is not None:
+ p_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = autils.encode_list(
+ [(10).to_bytes(1, byteorder="big"),
+ p_mf_1,
+ bytes(range(40))])
+ s_config = self.create_publish_config(
+ s_dut.aware_capabilities,
+ s_type,
+ self.PAYLOAD_SIZE_TYPICAL,
+ ttl=0,
+ term_ind_on=False,
+ null_match=False)
+ if s_service_name is not None:
+ s_config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = s_service_name
+ if s_mf_1 is not None:
+ s_config[aconsts.DISCOVERY_KEY_MATCH_FILTER_LIST] = autils.encode_list(
+ [(10).to_bytes(1, byteorder="big"),
+ s_mf_1,
+ bytes(range(40))])
+
+ p_id = p_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Publisher: start publish and wait for confirmation
+ p_disc_id = p_dut.droid.wifiAwarePublish(p_id, p_config)
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_disc_id = s_dut.droid.wifiAwareSubscribe(s_id, s_config)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
+
+ # Subscriber: fail on service discovery
+ if is_expected_to_pass:
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+ else:
+ autils.fail_on_event(s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
+
+ # Publisher+Subscriber: Terminate sessions
+ p_dut.droid.wifiAwareDestroyDiscoverySession(p_disc_id)
+ s_dut.droid.wifiAwareDestroyDiscoverySession(s_disc_id)
+
+ # verify that there were no other events (including terminations)
+ time.sleep(autils.EVENT_TIMEOUT)
+ autils.verify_no_more_events(p_dut, timeout=0)
+ autils.verify_no_more_events(s_dut, timeout=0)
+
+
+ #######################################
+ # Positive tests key:
+ #
+ # names is: test_<pub_type>_<sub_type>_<size>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ # size: Size of payload fields (service name, service specific info, and match
+ # filter: typical, max, or min.
+ #######################################
+
+ def test_positive_unsolicited_passive_typical(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Solicited publish + passive subscribe
+ - Typical payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ payload_size=self.PAYLOAD_SIZE_TYPICAL)
+
+ def test_positive_unsolicited_passive_min(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Solicited publish + passive subscribe
+ - Minimal payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ payload_size=self.PAYLOAD_SIZE_MIN)
+
+ def test_positive_unsolicited_passive_max(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Solicited publish + passive subscribe
+ - Maximal payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ payload_size=self.PAYLOAD_SIZE_MAX)
+
+
+ def test_positive_solicited_active_typical(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Unsolicited publish + active subscribe
+ - Typical payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ payload_size=self.PAYLOAD_SIZE_TYPICAL)
+
+ def test_positive_solicited_active_min(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Unsolicited publish + active subscribe
+ - Minimal payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ payload_size=self.PAYLOAD_SIZE_MIN)
+
+ def test_positive_solicited_active_max(self):
+ """Functional test case / Discovery test cases / positive test case:
+ - Unsolicited publish + active subscribe
+ - Maximal payload fields size
+
+ Verifies that discovery and message exchange succeeds.
+ """
+ self.positive_discovery_test_utility(
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ payload_size=self.PAYLOAD_SIZE_MAX)
+
+ #######################################
+ # TTL tests key:
+ #
+ # names is: test_ttl_<pub_type|sub_type>_<term_ind>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ # term_ind: ind_on or ind_off
+ #######################################
+
+ def test_ttl_unsolicited_ind_on(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Unsolicited publish
+ - Termination indication enabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=True,
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=None,
+ term_ind_on=True)
+
+ def test_ttl_unsolicited_ind_off(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Unsolicited publish
+ - Termination indication disabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=True,
+ ptype=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ stype=None,
+ term_ind_on=False)
+
+ def test_ttl_solicited_ind_on(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Solicited publish
+ - Termination indication enabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=True,
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=None,
+ term_ind_on=True)
+
+ def test_ttl_solicited_ind_off(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Solicited publish
+ - Termination indication disabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=True,
+ ptype=aconsts.PUBLISH_TYPE_SOLICITED,
+ stype=None,
+ term_ind_on=False)
+
+ def test_ttl_passive_ind_on(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Passive subscribe
+ - Termination indication enabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=False,
+ ptype=None,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ term_ind_on=True)
+
+ def test_ttl_passive_ind_off(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Passive subscribe
+ - Termination indication disabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=False,
+ ptype=None,
+ stype=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ term_ind_on=False)
+
+ def test_ttl_active_ind_on(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Active subscribe
+ - Termination indication enabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=False,
+ ptype=None,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ term_ind_on=True)
+
+ def test_ttl_active_ind_off(self):
+ """Functional test case / Discovery test cases / TTL test case:
+ - Active subscribe
+ - Termination indication disabled
+ """
+ self.positive_ttl_test_utility(
+ is_publish=False,
+ ptype=None,
+ stype=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ term_ind_on=False)
+
+ #######################################
+ # Mismatched service name tests key:
+ #
+ # names is: test_mismatch_service_name_<pub_type>_<sub_type>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ #######################################
+
+ def test_mismatch_service_name_unsolicited_passive(self):
+ """Functional test case / Discovery test cases / Mismatch service name
+ - Unsolicited publish
+ - Passive subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=False,
+ p_type=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ p_service_name="GoogleTestServiceXXX",
+ s_service_name="GoogleTestServiceYYY")
+
+ def test_mismatch_service_name_solicited_active(self):
+ """Functional test case / Discovery test cases / Mismatch service name
+ - Solicited publish
+ - Active subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=False,
+ p_type=aconsts.PUBLISH_TYPE_SOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ p_service_name="GoogleTestServiceXXX",
+ s_service_name="GoogleTestServiceYYY")
+
+ #######################################
+ # Mismatched discovery session type tests key:
+ #
+ # names is: test_mismatch_service_type_<pub_type>_<sub_type>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ #######################################
+
+ def test_mismatch_service_type_unsolicited_active(self):
+ """Functional test case / Discovery test cases / Mismatch service name
+ - Unsolicited publish
+ - Active subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=True,
+ p_type=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_ACTIVE)
+
+ def test_mismatch_service_type_solicited_passive(self):
+ """Functional test case / Discovery test cases / Mismatch service name
+ - Unsolicited publish
+ - Active subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=False,
+ p_type=aconsts.PUBLISH_TYPE_SOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_PASSIVE)
+
+ #######################################
+ # Mismatched discovery match filter tests key:
+ #
+ # names is: test_mismatch_match_filter_<pub_type>_<sub_type>
+ # where:
+ #
+ # pub_type: Type of publish discovery session: unsolicited or solicited.
+ # sub_type: Type of subscribe discovery session: passive or active.
+ #######################################
+
+ def test_mismatch_match_filter_unsolicited_passive(self):
+ """Functional test case / Discovery test cases / Mismatch match filter
+ - Unsolicited publish
+ - Passive subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=False,
+ p_type=aconsts.PUBLISH_TYPE_UNSOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ p_mf_1="hello there string",
+ s_mf_1="goodbye there string")
+
+ def test_mismatch_match_filter_solicited_active(self):
+ """Functional test case / Discovery test cases / Mismatch match filter
+ - Solicited publish
+ - Active subscribe
+ """
+ self.discovery_mismatch_test_utility(
+ is_expected_to_pass=False,
+ p_type=aconsts.PUBLISH_TYPE_SOLICITED,
+ s_type=aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ p_mf_1="hello there string",
+ s_mf_1="goodbye there string")
diff --git a/acts/tests/google/wifi/aware/functional/MacRandomTest.py b/acts/tests/google/wifi/aware/functional/MacRandomTest.py
new file mode 100644
index 0000000..8dabb04
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/MacRandomTest.py
@@ -0,0 +1,133 @@
+#!/usr/bin/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 time
+
+from acts import asserts
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class MacRandomTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware MAC address randomization of NMI (NAN
+ management interface) and NDI (NAN data interface)."""
+
+ NUM_ITERATIONS = 10
+
+ # number of second to 'reasonably' wait to make sure that devices synchronize
+ # with each other - useful for OOB test cases, where the OOB discovery would
+ # take some time
+ WAIT_FOR_CLUSTER = 5
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def request_network(self, dut, ns):
+ """Request a Wi-Fi Aware network.
+
+ Args:
+ dut: Device
+ ns: Network specifier
+ Returns: the request key
+ """
+ network_req = {"TransportType": 5, "NetworkSpecifier": ns}
+ return dut.droid.connectivityRequestWifiAwareNetwork(network_req)
+
+ ##########################################################################
+
+ def test_nmi_ndi_randomization_on_enable(self):
+ """Validate randomization of the NMI (NAN management interface) and all NDIs
+ (NAN data-interface) on each enable/disable cycle"""
+ dut = self.android_devices[0]
+
+ # DUT: attach and wait for confirmation & identity 10 times
+ mac_addresses = {}
+ for i in range(self.NUM_ITERATIONS):
+ id = dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+ ident_event = autils.wait_for_event(dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+
+ # process NMI
+ mac = ident_event["data"]["mac"]
+ dut.log.info("NMI=%s", mac)
+ if mac in mac_addresses:
+ mac_addresses[mac] = mac_addresses[mac] + 1
+ else:
+ mac_addresses[mac] = 1
+
+ # process NDIs
+ time.sleep(5) # wait for NDI creation to complete
+ for j in range(dut.aware_capabilities[aconsts.CAP_MAX_NDI_INTERFACES]):
+ ndi_interface = "%s%d" % (aconsts.AWARE_NDI_PREFIX, j)
+ ndi_mac = autils.get_mac_addr(dut, ndi_interface)
+ dut.log.info("NDI %s=%s", ndi_interface, ndi_mac)
+ if ndi_mac in mac_addresses:
+ mac_addresses[ndi_mac] = mac_addresses[ndi_mac] + 1
+ else:
+ mac_addresses[ndi_mac] = 1
+
+ dut.droid.wifiAwareDestroy(id)
+
+ # Test for uniqueness
+ for mac in mac_addresses.keys():
+ if mac_addresses[mac] != 1:
+ asserts.fail("MAC address %s repeated %d times (all=%s)" % (mac,
+ mac_addresses[mac], mac_addresses))
+
+ # Verify that infra interface (e.g. wlan0) MAC address is not used for NMI
+ infra_mac = autils.get_wifi_mac_address(dut)
+ asserts.assert_false(
+ infra_mac in mac_addresses,
+ "Infrastructure MAC address (%s) is used for Aware NMI (all=%s)" %
+ (infra_mac, mac_addresses))
+
+ def test_nmi_randomization_on_interval(self):
+ """Validate randomization of the NMI (NAN management interface) on a set
+ interval. Default value is 30 minutes - change to a small value to allow
+ testing in real-time"""
+ RANDOM_INTERVAL = 120 # minimal value in current implementation
+
+ dut = self.android_devices[0]
+
+ # set randomization interval to 5 seconds
+ dut.adb.shell("cmd wifiaware native_api set mac_random_interval_sec %d" %
+ RANDOM_INTERVAL)
+
+ # attach and wait for first identity
+ id = dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+ ident_event = autils.wait_for_event(dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ mac1 = ident_event["data"]["mac"]
+
+ # wait for second identity callback
+ # Note: exact randomization interval is not critical, just approximate,
+ # hence giving a few more seconds.
+ ident_event = autils.wait_for_event(dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED,
+ timeout=RANDOM_INTERVAL + 5)
+ mac2 = ident_event["data"]["mac"]
+
+ # validate MAC address is randomized
+ asserts.assert_false(
+ mac1 == mac2,
+ "Randomized MAC addresses (%s, %s) should be different" % (mac1, mac2))
+
+ # clean-up
+ dut.droid.wifiAwareDestroy(id)
diff --git a/acts/tests/google/wifi/aware/functional/MatchFilterTest.py b/acts/tests/google/wifi/aware/functional/MatchFilterTest.py
new file mode 100644
index 0000000..e01bfff
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/MatchFilterTest.py
@@ -0,0 +1,191 @@
+#!/usr/bin/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 base64
+import time
+import queue
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class MatchFilterTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware Discovery Match Filter behavior. These all
+ use examples from Appendix H of the Wi-Fi Aware standard."""
+
+ SERVICE_NAME = "GoogleTestServiceMFMFMF"
+
+ MF_NNNNN = bytes([0x0, 0x0, 0x0, 0x0, 0x0])
+ MF_12345 = bytes([0x1, 0x1, 0x1, 0x2, 0x1, 0x3, 0x1, 0x4, 0x1, 0x5])
+ MF_12145 = bytes([0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x4, 0x1, 0x5])
+ MF_1N3N5 = bytes([0x1, 0x1, 0x0, 0x1, 0x3, 0x0, 0x1, 0x5])
+ MF_N23N5 = bytes([0x0, 0x1, 0x2, 0x1, 0x3, 0x0, 0x1, 0x5])
+ MF_N2N4 = bytes([0x0, 0x1, 0x2, 0x0, 0x1, 0x4])
+ MF_1N3N = bytes([0x1, 0x1, 0x0, 0x1, 0x3, 0x0])
+
+ # Set of sample match filters from the spec. There is a set of matched
+ # filters:
+ # - Filter 1
+ # - Filter 2
+ # - Expected to match if the Subscriber uses Filter 1 as Tx and the Publisher
+ # uses Filter 2 as Rx (implies Solicited/Active)
+ # - (the reverse) Expected to match if the Publisher uses Filter 1 as Tx and
+ # the Subscriber uses Filter 2 as Rx (implies Unsolicited/Passive)
+ match_filters = [
+ [None, None, True, True],
+ [None, MF_NNNNN, True, True],
+ [MF_NNNNN, None, True, True],
+ [None, MF_12345, True, False],
+ [MF_12345, None, False, True],
+ [MF_NNNNN, MF_12345, True, True],
+ [MF_12345, MF_NNNNN, True, True],
+ [MF_12345, MF_12345, True, True],
+ [MF_12345, MF_12145, False, False],
+ [MF_1N3N5, MF_12345, True,True],
+ [MF_12345, MF_N23N5, True, True],
+ [MF_N2N4, MF_12345, True, False],
+ [MF_12345, MF_1N3N, False, True]
+ ]
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def run_discovery(self, p_dut, s_dut, p_mf, s_mf, do_unsolicited_passive,
+ expect_discovery):
+ """Creates a discovery session (publish and subscribe) with the specified
+ configuration.
+
+ Args:
+ p_dut: Device to use as publisher.
+ s_dut: Device to use as subscriber.
+ p_mf: Publish's match filter.
+ s_mf: Subscriber's match filter.
+ do_unsolicited_passive: True to use an Unsolicited/Passive discovery,
+ False for a Solicited/Active discovery session.
+ expect_discovery: True if service should be discovered, False otherwise.
+ Returns: True on success, False on failure (based on expect_discovery arg)
+ """
+ # Encode the match filters
+ p_mf = base64.b64encode(p_mf).decode("utf-8") if p_mf is not None else None
+ s_mf = base64.b64encode(s_mf).decode("utf-8") if s_mf is not None else None
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach()
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach()
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # Publisher: start publish and wait for confirmation
+ p_dut.droid.wifiAwarePublish(p_id,
+ autils.create_discovery_config(
+ self.SERVICE_NAME,
+ d_type=aconsts.PUBLISH_TYPE_UNSOLICITED
+ if do_unsolicited_passive else
+ aconsts.PUBLISH_TYPE_SOLICITED,
+ match_filter=p_mf))
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_dut.droid.wifiAwareSubscribe(s_id,
+ autils.create_discovery_config(
+ self.SERVICE_NAME,
+ d_type=aconsts.SUBSCRIBE_TYPE_PASSIVE
+ if do_unsolicited_passive else
+ aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ match_filter=s_mf))
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
+
+ # Subscriber: wait or fail on service discovery
+ event = None
+ try:
+ event = s_dut.ed.pop_event(aconsts.SESSION_CB_ON_SERVICE_DISCOVERED,
+ autils.EVENT_TIMEOUT)
+ s_dut.log.info("[Subscriber] SESSION_CB_ON_SERVICE_DISCOVERED: %s", event)
+ except queue.Empty:
+ s_dut.log.info("[Subscriber] No SESSION_CB_ON_SERVICE_DISCOVERED")
+
+ # clean-up
+ p_dut.droid.wifiAwareDestroy(p_id)
+ s_dut.droid.wifiAwareDestroy(s_id)
+
+ if expect_discovery:
+ return event is not None
+ else:
+ return event is None
+
+ def run_match_filters_per_spec(self, do_unsolicited_passive):
+ """Validate all the match filter combinations in the Wi-Fi Aware spec,
+ Appendix H.
+
+ Args:
+ do_unsolicited_passive: True to run the Unsolicited/Passive tests, False
+ to run the Solicited/Active tests.
+ """
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ fails = []
+ for i in range(len(self.match_filters)):
+ test_info = self.match_filters[i]
+ if do_unsolicited_passive:
+ pub_type = "Unsolicited"
+ sub_type = "Passive"
+ pub_mf = test_info[0]
+ sub_mf = test_info[1]
+ expect_discovery = test_info[3]
+ else:
+ pub_type = "Solicited"
+ sub_type = "Active"
+ pub_mf = test_info[1]
+ sub_mf = test_info[0]
+ expect_discovery = test_info[2]
+
+ self.log.info("Test #%d: %s Pub MF=%s, %s Sub MF=%s: Discovery %s", i,
+ pub_type, pub_mf, sub_type, sub_mf, "EXPECTED"
+ if test_info[2] else "UNEXPECTED")
+ result = self.run_discovery(
+ p_dut,
+ s_dut,
+ p_mf=pub_mf,
+ s_mf=sub_mf,
+ do_unsolicited_passive=do_unsolicited_passive,
+ expect_discovery=expect_discovery)
+ self.log.info("Test #%d %s Pub/%s Sub %s", i, pub_type, sub_type, "PASS"
+ if result else "FAIL")
+ if not result:
+ fails.append(i)
+
+ asserts.assert_true(
+ len(fails) == 0, "Some match filter tests are failing", extras=fails)
+
+ ###############################################################
+
+ def test_match_filters_per_spec_unsolicited_passive(self):
+ """Validate all the match filter combinations in the Wi-Fi Aware spec,
+ Appendix H for Unsolicited Publish (tx filter) Passive Subscribe (rx
+ filter)"""
+ self.run_match_filters_per_spec(do_unsolicited_passive=True)
+
+ def test_match_filters_per_spec_solicited_active(self):
+ """Validate all the match filter combinations in the Wi-Fi Aware spec,
+ Appendix H for Solicited Publish (rx filter) Active Subscribe (tx
+ filter)"""
+ self.run_match_filters_per_spec(do_unsolicited_passive=False)
diff --git a/acts/tests/google/wifi/aware/functional/MessageTest.py b/acts/tests/google/wifi/aware/functional/MessageTest.py
new file mode 100644
index 0000000..1abca68
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/MessageTest.py
@@ -0,0 +1,437 @@
+#!/usr/bin/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 string
+import time
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class MessageTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware L2 (layer 2) message exchanges."""
+
+ # configuration parameters used by tests
+ PAYLOAD_SIZE_MIN = 0
+ PAYLOAD_SIZE_TYPICAL = 1
+ PAYLOAD_SIZE_MAX = 2
+
+ NUM_MSGS_NO_QUEUE = 10
+ NUM_MSGS_QUEUE_DEPTH_MULT = 2 # number of messages = mult * queue depth
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def create_msg(self, caps, payload_size, id):
+ """Creates a message string of the specified size containing the input id.
+
+ Args:
+ caps: Device capabilities.
+ payload_size: The size of the message to create - min (null or empty
+ message), typical, max (based on device capabilities). Use
+ the PAYLOAD_SIZE_xx constants.
+ id: Information to include in the generated message (or None).
+
+ Returns: A string of the requested size, optionally containing the id.
+ """
+ if payload_size == self.PAYLOAD_SIZE_MIN:
+ # arbitrarily return a None or an empty string (equivalent messages)
+ return None if id % 2 == 0 else ""
+ elif payload_size == self.PAYLOAD_SIZE_TYPICAL:
+ return "*** ID=%d ***" % id + string.ascii_uppercase
+ else: # PAYLOAD_SIZE_MAX
+ return "*** ID=%4d ***" % id + "M" * (
+ caps[aconsts.CAP_MAX_SERVICE_SPECIFIC_INFO_LEN] - 15)
+
+ def create_config(self, is_publish, extra_diff=None):
+ """Create a base configuration based on input parameters.
+
+ Args:
+ is_publish: True for publish, False for subscribe sessions.
+ extra_diff: String to add to service name: allows differentiating
+ discovery sessions.
+
+ Returns:
+ publish discovery configuration object.
+ """
+ config = {}
+ if is_publish:
+ config[aconsts.
+ DISCOVERY_KEY_DISCOVERY_TYPE] = aconsts.PUBLISH_TYPE_UNSOLICITED
+ else:
+ config[
+ aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = aconsts.SUBSCRIBE_TYPE_PASSIVE
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "GoogleTestServiceX" + (
+ extra_diff if extra_diff is not None else "")
+ return config
+
+ def prep_message_exchange(self, extra_diff=None):
+ """Creates a discovery session (publish and subscribe), and waits for
+ service discovery - at that point the sessions are ready for message
+ exchange.
+
+ Args:
+ extra_diff: String to add to service name: allows differentiating
+ discovery sessions.
+ """
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # if differentiating (multiple) sessions then should decorate events with id
+ use_id = extra_diff is not None
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach(False, None, use_id)
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED
+ if not use_id else autils.decorate_event(
+ aconsts.EVENT_CB_ON_ATTACHED, p_id))
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach(False, None, use_id)
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED
+ if not use_id else autils.decorate_event(
+ aconsts.EVENT_CB_ON_ATTACHED, s_id))
+
+ # Publisher: start publish and wait for confirmation
+ p_disc_id = p_dut.droid.wifiAwarePublish(p_id,
+ self.create_config(
+ True, extra_diff=extra_diff),
+ use_id)
+ autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED
+ if not use_id else autils.decorate_event(
+ aconsts.SESSION_CB_ON_PUBLISH_STARTED, p_disc_id))
+
+ # Subscriber: start subscribe and wait for confirmation
+ s_disc_id = s_dut.droid.wifiAwareSubscribe(
+ s_id, self.create_config(False, extra_diff=extra_diff), use_id)
+ autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED
+ if not use_id else autils.decorate_event(
+ aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED,
+ s_disc_id))
+
+ # Subscriber: wait for service discovery
+ discovery_event = autils.wait_for_event(
+ s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED
+ if not use_id else autils.decorate_event(
+ aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, s_disc_id))
+ peer_id_on_sub = discovery_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+
+ return {
+ "p_dut": p_dut,
+ "s_dut": s_dut,
+ "p_id": p_id,
+ "s_id": s_id,
+ "p_disc_id": p_disc_id,
+ "s_disc_id": s_disc_id,
+ "peer_id_on_sub": peer_id_on_sub
+ }
+
+ def run_message_no_queue(self, payload_size):
+ """Validate L2 message exchange between publisher & subscriber with no
+ queueing - i.e. wait for an ACK on each message before sending the next
+ message.
+
+ Args:
+ payload_size: min, typical, or max (PAYLOAD_SIZE_xx).
+ """
+ discovery_info = self.prep_message_exchange()
+ p_dut = discovery_info["p_dut"]
+ s_dut = discovery_info["s_dut"]
+ p_disc_id = discovery_info["p_disc_id"]
+ s_disc_id = discovery_info["s_disc_id"]
+ peer_id_on_sub = discovery_info["peer_id_on_sub"]
+
+ for i in range(self.NUM_MSGS_NO_QUEUE):
+ msg = self.create_msg(s_dut.aware_capabilities, payload_size, i)
+ msg_id = self.get_next_msg_id()
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, msg_id, msg,
+ 0)
+ tx_event = autils.wait_for_event(s_dut,
+ aconsts.SESSION_CB_ON_MESSAGE_SENT)
+ rx_event = autils.wait_for_event(p_dut,
+ aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ asserts.assert_equal(msg_id,
+ tx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_ID],
+ "Subscriber -> Publisher message ID corrupted")
+ autils.assert_equal_strings(
+ msg, rx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING],
+ "Subscriber -> Publisher message %d corrupted" % i)
+
+ peer_id_on_pub = rx_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+ for i in range(self.NUM_MSGS_NO_QUEUE):
+ msg = self.create_msg(s_dut.aware_capabilities, payload_size, 1000 + i)
+ msg_id = self.get_next_msg_id()
+ p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub, msg_id, msg,
+ 0)
+ tx_event = autils.wait_for_event(p_dut,
+ aconsts.SESSION_CB_ON_MESSAGE_SENT)
+ rx_event = autils.wait_for_event(s_dut,
+ aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
+ asserts.assert_equal(msg_id,
+ tx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_ID],
+ "Publisher -> Subscriber message ID corrupted")
+ autils.assert_equal_strings(
+ msg, rx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING],
+ "Publisher -> Subscriber message %d corrupted" % i)
+
+ # verify there are no more events
+ time.sleep(autils.EVENT_TIMEOUT)
+ autils.verify_no_more_events(p_dut, timeout=0)
+ autils.verify_no_more_events(s_dut, timeout=0)
+
+ def wait_for_messages(self, tx_msgs, tx_msg_ids, tx_disc_id, rx_disc_id,
+ tx_dut, rx_dut, are_msgs_empty=False):
+ """Validate that all expected messages are transmitted correctly and
+ received as expected. Method is called after the messages are sent into
+ the transmission queue.
+
+ Note: that message can be transmitted and received out-of-order (which is
+ acceptable and the method handles that correctly).
+
+ Args:
+ tx_msgs: dictionary of transmitted messages
+ tx_msg_ids: dictionary of transmitted message ids
+ tx_disc_id: transmitter discovery session id (None for no decoration)
+ rx_disc_id: receiver discovery session id (None for no decoration)
+ tx_dut: transmitter device
+ rx_dut: receiver device
+ are_msgs_empty: True if the messages are None or empty (changes dup detection)
+
+ Returns: the peer ID from any of the received messages
+ """
+ # peer id on receiver
+ peer_id_on_rx = None
+
+ # wait for all messages to be transmitted
+ still_to_be_tx = len(tx_msg_ids)
+ while still_to_be_tx != 0:
+ tx_event = autils.wait_for_event(
+ tx_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT
+ if tx_disc_id is None else autils.decorate_event(
+ aconsts.SESSION_CB_ON_MESSAGE_SENT, tx_disc_id))
+ tx_msg_id = tx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_ID]
+ tx_msg_ids[tx_msg_id] = tx_msg_ids[tx_msg_id] + 1
+ if tx_msg_ids[tx_msg_id] == 1:
+ still_to_be_tx = still_to_be_tx - 1
+
+ # check for any duplicate transmit notifications
+ asserts.assert_equal(
+ len(tx_msg_ids),
+ sum(tx_msg_ids.values()),
+ "Duplicate transmit message IDs: %s" % tx_msg_ids)
+
+ # wait for all messages to be received
+ still_to_be_rx = len(tx_msg_ids)
+ while still_to_be_rx != 0:
+ rx_event = autils.wait_for_event(
+ rx_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED
+ if rx_disc_id is None else autils.decorate_event(
+ aconsts.SESSION_CB_ON_MESSAGE_RECEIVED, rx_disc_id))
+ peer_id_on_rx = rx_event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
+ if are_msgs_empty:
+ still_to_be_rx = still_to_be_rx - 1
+ else:
+ rx_msg = rx_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING]
+ asserts.assert_true(
+ rx_msg in tx_msgs,
+ "Received a message we did not send!? -- '%s'" % rx_msg)
+ tx_msgs[rx_msg] = tx_msgs[rx_msg] + 1
+ if tx_msgs[rx_msg] == 1:
+ still_to_be_rx = still_to_be_rx - 1
+
+ # check for any duplicate received messages
+ if not are_msgs_empty:
+ asserts.assert_equal(
+ len(tx_msgs),
+ sum(tx_msgs.values()), "Duplicate transmit messages: %s" % tx_msgs)
+
+ return peer_id_on_rx
+
+ def run_message_with_queue(self, payload_size):
+ """Validate L2 message exchange between publisher & subscriber with
+ queueing - i.e. transmit all messages and then wait for ACKs.
+
+ Args:
+ payload_size: min, typical, or max (PAYLOAD_SIZE_xx).
+ """
+ discovery_info = self.prep_message_exchange()
+ p_dut = discovery_info["p_dut"]
+ s_dut = discovery_info["s_dut"]
+ p_disc_id = discovery_info["p_disc_id"]
+ s_disc_id = discovery_info["s_disc_id"]
+ peer_id_on_sub = discovery_info["peer_id_on_sub"]
+
+ msgs = {}
+ msg_ids = {}
+ for i in range(
+ self.NUM_MSGS_QUEUE_DEPTH_MULT *
+ s_dut.aware_capabilities[aconsts.CAP_MAX_QUEUED_TRANSMIT_MESSAGES]):
+ msg = self.create_msg(s_dut.aware_capabilities, payload_size, i)
+ msg_id = self.get_next_msg_id()
+ msgs[msg] = 0
+ msg_ids[msg_id] = 0
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, msg_id, msg,
+ 0)
+ peer_id_on_pub = self.wait_for_messages(
+ msgs, msg_ids, None, None, s_dut, p_dut,
+ payload_size == self.PAYLOAD_SIZE_MIN)
+
+ msgs = {}
+ msg_ids = {}
+ for i in range(
+ self.NUM_MSGS_QUEUE_DEPTH_MULT *
+ p_dut.aware_capabilities[aconsts.CAP_MAX_QUEUED_TRANSMIT_MESSAGES]):
+ msg = self.create_msg(p_dut.aware_capabilities, payload_size, 1000 + i)
+ msg_id = self.get_next_msg_id()
+ msgs[msg] = 0
+ msg_ids[msg_id] = 0
+ p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub, msg_id, msg,
+ 0)
+ self.wait_for_messages(msgs, msg_ids, None, None, p_dut, s_dut,
+ payload_size == self.PAYLOAD_SIZE_MIN)
+
+ # verify there are no more events
+ time.sleep(autils.EVENT_TIMEOUT)
+ autils.verify_no_more_events(p_dut, timeout=0)
+ autils.verify_no_more_events(s_dut, timeout=0)
+
+ def run_message_multi_session_with_queue(self, payload_size):
+ """Validate L2 message exchange between publishers & subscribers with
+ queueing - i.e. transmit all messages and then wait for ACKs. Uses 2
+ discovery sessions running concurrently and validates that messages
+ arrive at the correct destination.
+
+ Args:
+ payload_size: min, typical, or max (PAYLOAD_SIZE_xx)
+ """
+ discovery_info1 = self.prep_message_exchange(extra_diff="-111")
+ p_dut = discovery_info1["p_dut"] # same for both sessions
+ s_dut = discovery_info1["s_dut"] # same for both sessions
+ p_disc_id1 = discovery_info1["p_disc_id"]
+ s_disc_id1 = discovery_info1["s_disc_id"]
+ peer_id_on_sub1 = discovery_info1["peer_id_on_sub"]
+
+ discovery_info2 = self.prep_message_exchange(extra_diff="-222")
+ p_disc_id2 = discovery_info2["p_disc_id"]
+ s_disc_id2 = discovery_info2["s_disc_id"]
+ peer_id_on_sub2 = discovery_info2["peer_id_on_sub"]
+
+ msgs1 = {}
+ msg_ids1 = {}
+ msgs2 = {}
+ msg_ids2 = {}
+ for i in range(
+ self.NUM_MSGS_QUEUE_DEPTH_MULT *
+ s_dut.aware_capabilities[aconsts.CAP_MAX_QUEUED_TRANSMIT_MESSAGES]):
+ msg1 = self.create_msg(s_dut.aware_capabilities, payload_size, i)
+ msg_id1 = self.get_next_msg_id()
+ msgs1[msg1] = 0
+ msg_ids1[msg_id1] = 0
+ s_dut.droid.wifiAwareSendMessage(s_disc_id1, peer_id_on_sub1, msg_id1,
+ msg1, 0)
+ msg2 = self.create_msg(s_dut.aware_capabilities, payload_size, 100 + i)
+ msg_id2 = self.get_next_msg_id()
+ msgs2[msg2] = 0
+ msg_ids2[msg_id2] = 0
+ s_dut.droid.wifiAwareSendMessage(s_disc_id2, peer_id_on_sub2, msg_id2,
+ msg2, 0)
+
+ peer_id_on_pub1 = self.wait_for_messages(
+ msgs1, msg_ids1, s_disc_id1, p_disc_id1, s_dut, p_dut,
+ payload_size == self.PAYLOAD_SIZE_MIN)
+ peer_id_on_pub2 = self.wait_for_messages(
+ msgs2, msg_ids2, s_disc_id2, p_disc_id2, s_dut, p_dut,
+ payload_size == self.PAYLOAD_SIZE_MIN)
+
+ msgs1 = {}
+ msg_ids1 = {}
+ msgs2 = {}
+ msg_ids2 = {}
+ for i in range(
+ self.NUM_MSGS_QUEUE_DEPTH_MULT *
+ p_dut.aware_capabilities[aconsts.CAP_MAX_QUEUED_TRANSMIT_MESSAGES]):
+ msg1 = self.create_msg(p_dut.aware_capabilities, payload_size, 1000 + i)
+ msg_id1 = self.get_next_msg_id()
+ msgs1[msg1] = 0
+ msg_ids1[msg_id1] = 0
+ p_dut.droid.wifiAwareSendMessage(p_disc_id1, peer_id_on_pub1, msg_id1,
+ msg1, 0)
+ msg2 = self.create_msg(p_dut.aware_capabilities, payload_size, 1100 + i)
+ msg_id2 = self.get_next_msg_id()
+ msgs2[msg2] = 0
+ msg_ids2[msg_id2] = 0
+ p_dut.droid.wifiAwareSendMessage(p_disc_id2, peer_id_on_pub2, msg_id2,
+ msg2, 0)
+
+ self.wait_for_messages(msgs1, msg_ids1, p_disc_id1, s_disc_id1, p_dut,
+ s_dut, payload_size == self.PAYLOAD_SIZE_MIN)
+ self.wait_for_messages(msgs2, msg_ids2, p_disc_id2, s_disc_id2, p_dut,
+ s_dut, payload_size == self.PAYLOAD_SIZE_MIN)
+
+ # verify there are no more events
+ time.sleep(autils.EVENT_TIMEOUT)
+ autils.verify_no_more_events(p_dut, timeout=0)
+ autils.verify_no_more_events(s_dut, timeout=0)
+
+ ############################################################################
+
+ def test_message_no_queue_min(self):
+ """Functional / Message / No queue
+ - Minimal payload size (None or "")
+ """
+ self.run_message_no_queue(self.PAYLOAD_SIZE_MIN)
+
+ def test_message_no_queue_typical(self):
+ """Functional / Message / No queue
+ - Typical payload size
+ """
+ self.run_message_no_queue(self.PAYLOAD_SIZE_TYPICAL)
+
+ def test_message_no_queue_max(self):
+ """Functional / Message / No queue
+ - Max payload size (based on device capabilities)
+ """
+ self.run_message_no_queue(self.PAYLOAD_SIZE_MAX)
+
+ def test_message_with_queue_min(self):
+ """Functional / Message / With queue
+ - Minimal payload size (none or "")
+ """
+ self.run_message_with_queue(self.PAYLOAD_SIZE_MIN)
+
+ def test_message_with_queue_typical(self):
+ """Functional / Message / With queue
+ - Typical payload size
+ """
+ self.run_message_with_queue(self.PAYLOAD_SIZE_TYPICAL)
+
+ def test_message_with_queue_max(self):
+ """Functional / Message / With queue
+ - Max payload size (based on device capabilities)
+ """
+ self.run_message_with_queue(self.PAYLOAD_SIZE_MAX)
+
+ def test_message_with_multiple_discovery_sessions_typical(self):
+ """Functional / Message / Multiple sessions
+
+ Sets up 2 discovery sessions on 2 devices. Sends a message in each
+ direction on each discovery session and verifies that reaches expected
+ destination.
+ """
+ self.run_message_multi_session_with_queue(self.PAYLOAD_SIZE_TYPICAL)
diff --git a/acts/tests/google/wifi/aware/functional/NonConcurrencyTest.py b/acts/tests/google/wifi/aware/functional/NonConcurrencyTest.py
new file mode 100644
index 0000000..d0b83cf
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/NonConcurrencyTest.py
@@ -0,0 +1,115 @@
+#!/usr/bin/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.
+
+from acts import asserts
+from acts.test_utils.wifi import wifi_test_utils as wutils
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class NonConcurrencyTest(AwareBaseTest):
+ """Tests lack of concurrency scenarios Wi-Fi Aware with WFD (p2p) and
+ SoftAP
+
+ Note: these tests should be modified if the concurrency behavior changes!"""
+
+ SERVICE_NAME = "GoogleTestXYZ"
+ TETHER_SSID = "GoogleTestSoftApXYZ"
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def teardown_test(self):
+ AwareBaseTest.teardown_test(self)
+ for ad in self.android_devices:
+ ad.droid.wifiP2pClose()
+
+ def run_aware_then_incompat_service(self, is_p2p):
+ """Run test to validate that a running Aware session terminates when an
+ Aware-incompatible service is started.
+
+ Args:
+ is_p2p: True for p2p, False for SoftAP
+ """
+ dut = self.android_devices[0]
+
+ # start Aware
+ id = dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # start other service
+ if is_p2p:
+ dut.droid.wifiP2pInitialize()
+ else:
+ wutils.start_wifi_tethering(dut, self.TETHER_SSID, password=None)
+
+ # expect an announcement about Aware non-availability
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
+
+ # local clean-up
+ if not is_p2p:
+ wutils.stop_wifi_tethering(dut)
+
+ def run_incompat_service_then_aware(self, is_p2p):
+ """Validate that if an Aware-incompatible service is already up then any
+ Aware operation fails"""
+ dut = self.android_devices[0]
+
+ # start other service
+ if is_p2p:
+ dut.droid.wifiP2pInitialize()
+ else:
+ wutils.start_wifi_tethering(dut, self.TETHER_SSID, password=None)
+
+ # expect an announcement about Aware non-availability
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_NOT_AVAILABLE)
+
+ # try starting anyway (expect failure)
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACH_FAILED)
+
+ # stop other service
+ if is_p2p:
+ dut.droid.wifiP2pClose()
+ else:
+ wutils.stop_wifi_tethering(dut)
+
+ # expect an announcement about Aware availability
+ autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
+
+ # try starting Aware
+ dut.droid.wifiAwareAttach()
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ ##########################################################################
+
+ def test_run_p2p_then_aware(self):
+ """Validate that if p2p is already up then any Aware operation fails"""
+ self.run_incompat_service_then_aware(is_p2p=True)
+
+ def test_run_aware_then_p2p(self):
+ """Validate that a running Aware session terminates when p2p is started"""
+ self.run_aware_then_incompat_service(is_p2p=True)
+
+ def test_run_softap_then_aware(self):
+ """Validate that if SoftAp is already up then any Aware operation fails"""
+ self.run_incompat_service_then_aware(is_p2p=False)
+
+ def test_run_aware_then_softap(self):
+ """Validate that a running Aware session terminates when softAp is
+ started"""
+ self.run_aware_then_incompat_service(is_p2p=False)
diff --git a/acts/tests/google/wifi/aware/functional/ProtocolsTest.py b/acts/tests/google/wifi/aware/functional/ProtocolsTest.py
new file mode 100644
index 0000000..bf4a561
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/ProtocolsTest.py
@@ -0,0 +1,193 @@
+#!/usr/bin/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.
+
+from acts import asserts
+from acts.test_utils.net import nsd_const as nconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class ProtocolsTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware data-paths: validating protocols running on
+ top of a data-path"""
+
+ SERVICE_NAME = "GoogleTestServiceXY"
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def run_ping6(self, dut, peer_ipv6, dut_if):
+ """Run a ping6 over the specified device/link
+
+ Args:
+ dut: Device on which to execute ping6
+ peer_ipv6: IPv6 address of the peer to ping
+ dut_if: interface name on the dut
+ """
+ cmd = "ping6 -c 3 -W 5 %s%%%s" % (peer_ipv6, dut_if)
+ 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 test_ping6_oob(self):
+ """Validate that ping6 works correctly on an NDP created using OOB (out-of
+ band) discovery"""
+ init_dut = self.android_devices[0]
+ resp_dut = self.android_devices[1]
+
+ # create NDP
+ (init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
+ resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
+ self.log.info("Interface names: I=%s, R=%s", init_aware_if, resp_aware_if)
+ self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
+ resp_ipv6)
+
+ # run ping6
+ self.run_ping6(init_dut, resp_ipv6, init_aware_if)
+ self.run_ping6(resp_dut, init_ipv6, resp_aware_if)
+
+ # clean-up
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+
+ def test_ping6_ib_unsolicited_passive(self):
+ """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]
+
+ # 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)
+
+ # run ping6
+ self.run_ping6(p_dut, s_ipv6, p_aware_if)
+ self.run_ping6(s_dut, p_ipv6, s_aware_if)
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ def test_ping6_ib_solicited_active(self):
+ """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]
+
+ # 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)
+
+ # run ping6
+ self.run_ping6(p_dut, s_ipv6, p_aware_if)
+ self.run_ping6(s_dut, p_ipv6, s_aware_if)
+
+ # clean-up
+ p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
+ s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
+
+ def test_nsd_oob(self):
+ """Validate that NSD (mDNS) works correctly on an NDP created using OOB
+ (out-of band) discovery"""
+ init_dut = self.android_devices[0]
+ resp_dut = self.android_devices[1]
+
+ # create NDP
+ (init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
+ resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
+ self.log.info("Interface names: I=%s, R=%s", init_aware_if, resp_aware_if)
+ self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
+ resp_ipv6)
+
+ # run NSD
+ nsd_service_info = {
+ "serviceInfoServiceName": "sl4aTestAwareNsd",
+ "serviceInfoServiceType": "_simple-tx-rx._tcp.",
+ "serviceInfoPort": 2257
+ }
+ nsd_reg = None
+ nsd_discovery = None
+ try:
+ # Initiator registers an NSD service
+ nsd_reg = init_dut.droid.nsdRegisterService(nsd_service_info)
+ event_nsd = autils.wait_for_event_with_keys(
+ init_dut, nconsts.REG_LISTENER_EVENT, autils.EVENT_TIMEOUT,
+ (nconsts.REG_LISTENER_CALLBACK,
+ nconsts.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED))
+ self.log.info("Initiator %s: %s",
+ nconsts.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED,
+ event_nsd["data"])
+
+ # Responder starts an NSD discovery
+ nsd_discovery = resp_dut.droid.nsdDiscoverServices(
+ nsd_service_info[nconsts.NSD_SERVICE_INFO_SERVICE_TYPE])
+ event_nsd = autils.wait_for_event_with_keys(
+ resp_dut, nconsts.DISCOVERY_LISTENER_EVENT, autils.EVENT_TIMEOUT,
+ (nconsts.DISCOVERY_LISTENER_DATA_CALLBACK,
+ nconsts.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND))
+ self.log.info("Responder %s: %s",
+ nconsts.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND,
+ event_nsd["data"])
+
+ # Responder resolves IP address of Initiator from NSD service discovery
+ resp_dut.droid.nsdResolveService(event_nsd["data"])
+ event_nsd = autils.wait_for_event_with_keys(
+ resp_dut, nconsts.RESOLVE_LISTENER_EVENT, autils.EVENT_TIMEOUT,
+ (nconsts.RESOLVE_LISTENER_DATA_CALLBACK,
+ nconsts.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED))
+ self.log.info("Responder %s: %s",
+ nconsts.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED,
+ event_nsd["data"])
+
+ # mDNS returns first character as '/' - strip
+ # out to get clean IPv6
+ init_ipv6_nsd = event_nsd["data"][nconsts.NSD_SERVICE_INFO_HOST][1:]
+
+ asserts.assert_equal(
+ init_ipv6, init_ipv6_nsd,
+ "Initiator's IPv6 address obtained through NSD doesn't match!?")
+ finally:
+ # Stop NSD
+ if nsd_reg is not None:
+ init_dut.droid.nsdUnregisterService(nsd_reg)
+ if nsd_discovery is not None:
+ resp_dut.droid.nsdStopServiceDiscovery(nsd_discovery)
+
+ # clean-up
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
diff --git a/acts/tests/google/wifi/aware/functional/functional b/acts/tests/google/wifi/aware/functional/functional
new file mode 100644
index 0000000..e13a470
--- /dev/null
+++ b/acts/tests/google/wifi/aware/functional/functional
@@ -0,0 +1,9 @@
+AttachTest
+DiscoveryTest
+MessageTest
+DataPathTest
+MacRandomTest
+CapabilitiesTest
+ProtocolsTest
+NonConcurrencyTest
+MatchFilterTest
\ No newline at end of file
diff --git a/acts/tests/google/wifi/aware/ota/ServiceIdsTest.py b/acts/tests/google/wifi/aware/ota/ServiceIdsTest.py
new file mode 100644
index 0000000..1137303
--- /dev/null
+++ b/acts/tests/google/wifi/aware/ota/ServiceIdsTest.py
@@ -0,0 +1,100 @@
+#!/usr/bin/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 time
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class ServiceIdsTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware to verify that beacons include service IDs
+ for discovery.
+
+ Note: this test is an OTA (over-the-air) and requires a Sniffer.
+ """
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def start_discovery_session(self, dut, session_id, is_publish, dtype,
+ service_name):
+ """Start a discovery session
+
+ Args:
+ dut: Device under test
+ session_id: ID of the Aware session in which to start discovery
+ is_publish: True for a publish session, False for subscribe session
+ dtype: Type of the discovery session
+ service_name: Service name to use for the discovery session
+
+ Returns:
+ Discovery session ID.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = service_name
+
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_PUBLISH_STARTED
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED
+
+ autils.wait_for_event(dut, event_name)
+ return disc_id
+
+ ####################################################################
+
+ def test_service_ids_in_beacon(self):
+ """Verify that beacons include service IDs for both publish and subscribe
+ sessions of all types: solicited/unsolicited/active/passive."""
+ dut = self.android_devices[0]
+
+ self.log.info("Reminder: start a sniffer before running test")
+
+ # attach
+ session_id = dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+ ident_event = autils.wait_for_event(dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ mac = ident_event["data"]["mac"]
+ self.log.info("Source MAC Address of 'interesting' packets = %s", mac)
+ self.log.info("Wireshark filter = 'wlan.ta == %s:%s:%s:%s:%s:%s'", mac[0:2],
+ mac[2:4], mac[4:6], mac[6:8], mac[8:10], mac[10:12])
+
+ time.sleep(5) # get some samples pre-discovery
+
+ # start 4 discovery session (one of each type)
+ self.start_discovery_session(dut, session_id, True,
+ aconsts.PUBLISH_TYPE_UNSOLICITED,
+ "GoogleTestService-Pub-Unsolicited")
+ self.start_discovery_session(dut, session_id, True,
+ aconsts.PUBLISH_TYPE_SOLICITED,
+ "GoogleTestService-Pub-Solicited")
+ self.start_discovery_session(dut, session_id, False,
+ aconsts.SUBSCRIBE_TYPE_ACTIVE,
+ "GoogleTestService-Sub-Active")
+ self.start_discovery_session(dut, session_id, False,
+ aconsts.SUBSCRIBE_TYPE_PASSIVE,
+ "GoogleTestService-Sub-Passive")
+
+ time.sleep(15) # get some samples while discovery is alive
+
+ self.log.info("Reminder: stop sniffer")
diff --git a/acts/tests/google/wifi/aware/ota/ota b/acts/tests/google/wifi/aware/ota/ota
new file mode 100644
index 0000000..27f6724
--- /dev/null
+++ b/acts/tests/google/wifi/aware/ota/ota
@@ -0,0 +1 @@
+ServiceIdsTest
\ No newline at end of file
diff --git a/acts/tests/google/wifi/aware/performance/LatencyTest.py b/acts/tests/google/wifi/aware/performance/LatencyTest.py
new file mode 100644
index 0000000..20176c1
--- /dev/null
+++ b/acts/tests/google/wifi/aware/performance/LatencyTest.py
@@ -0,0 +1,555 @@
+#!/usr/bin/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 queue
+import time
+
+from acts import asserts
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class LatencyTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware to measure latency of Aware operations."""
+ SERVICE_NAME = "GoogleTestServiceXY"
+
+ # number of second to 'reasonably' wait to make sure that devices synchronize
+ # with each other - useful for OOB test cases, where the OOB discovery would
+ # take some time
+ WAIT_FOR_CLUSTER = 5
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def start_discovery_session(self, dut, session_id, is_publish, dtype):
+ """Start a discovery session
+
+ Args:
+ dut: Device under test
+ session_id: ID of the Aware session in which to start discovery
+ is_publish: True for a publish session, False for subscribe session
+ dtype: Type of the discovery session
+
+ Returns:
+ Discovery session started event.
+ """
+ config = {}
+ config[aconsts.DISCOVERY_KEY_DISCOVERY_TYPE] = dtype
+ config[aconsts.DISCOVERY_KEY_SERVICE_NAME] = "GoogleTestServiceXY"
+
+ if is_publish:
+ disc_id = dut.droid.wifiAwarePublish(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_PUBLISH_STARTED
+ else:
+ disc_id = dut.droid.wifiAwareSubscribe(session_id, config)
+ event_name = aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED
+
+ event = autils.wait_for_event(dut, event_name)
+ return disc_id, event
+
+ def run_synchronization_latency(self, results, do_unsolicited_passive,
+ dw_24ghz, dw_5ghz, num_iterations,
+ startup_offset, timeout_period):
+ """Run the synchronization latency test with the specified DW intervals.
+ There is no direct measure of synchronization. Instead starts a discovery
+ session as soon as possible and measures both probability of discovery
+ within a timeout period and the actual discovery time (not necessarily
+ accurate).
+
+ Args:
+ results: Result array to be populated - will add results (not erase it)
+ do_unsolicited_passive: True for unsolicited/passive, False for
+ solicited/active.
+ dw_24ghz: DW interval in the 2.4GHz band.
+ dw_5ghz: DW interval in the 5GHz band.
+ startup_offset: The start-up gap (in seconds) between the two devices
+ timeout_period: Time period over which to measure synchronization
+ """
+ key = "%s_dw24_%d_dw5_%d_offset_%d" % (
+ "unsolicited_passive" if do_unsolicited_passive else "solicited_active",
+ dw_24ghz, dw_5ghz, startup_offset)
+ results[key] = {}
+ results[key]["num_iterations"] = num_iterations
+
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # override the default DW configuration
+ autils.config_dw_all_modes(p_dut, dw_24ghz, dw_5ghz)
+ autils.config_dw_all_modes(s_dut, dw_24ghz, dw_5ghz)
+
+ latencies = []
+ failed_discoveries = 0
+ for i in range(num_iterations):
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # start publish
+ p_disc_id, p_disc_event = self.start_discovery_session(
+ p_dut, p_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED
+ if do_unsolicited_passive else aconsts.PUBLISH_TYPE_SOLICITED)
+
+ # start subscribe
+ s_disc_id, s_session_event = self.start_discovery_session(
+ s_dut, s_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE
+ if do_unsolicited_passive else aconsts.SUBSCRIBE_TYPE_ACTIVE)
+
+ # wait for discovery (allow for failures here since running lots of
+ # samples and would like to get the partial data even in the presence of
+ # errors)
+ try:
+ discovery_event = s_dut.ed.pop_event(
+ aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, timeout_period)
+ s_dut.log.info("[Subscriber] SESSION_CB_ON_SERVICE_DISCOVERED: %s",
+ discovery_event["data"])
+ except queue.Empty:
+ s_dut.log.info("[Subscriber] Timed out while waiting for "
+ "SESSION_CB_ON_SERVICE_DISCOVERED")
+ failed_discoveries = failed_discoveries + 1
+ continue
+ finally:
+ # destroy sessions
+ p_dut.droid.wifiAwareDestroyDiscoverySession(p_disc_id)
+ s_dut.droid.wifiAwareDestroyDiscoverySession(s_disc_id)
+ p_dut.droid.wifiAwareDestroy(p_id)
+ s_dut.droid.wifiAwareDestroy(s_id)
+
+ # collect latency information
+ latencies.append(
+ discovery_event["data"][aconsts.SESSION_CB_KEY_TIMESTAMP_MS] -
+ s_session_event["data"][aconsts.SESSION_CB_KEY_TIMESTAMP_MS])
+ self.log.info("Latency #%d = %d" % (i, latencies[-1]))
+
+ autils.extract_stats(
+ s_dut,
+ data=latencies,
+ results=results[key],
+ key_prefix="",
+ log_prefix="Subscribe Session Sync/Discovery (%s, dw24=%d, dw5=%d)" %
+ ("Unsolicited/Passive"
+ if do_unsolicited_passive else "Solicited/Active", dw_24ghz, dw_5ghz))
+ results[key]["num_failed_discovery"] = failed_discoveries
+
+ def run_discovery_latency(self, results, do_unsolicited_passive, dw_24ghz,
+ dw_5ghz, num_iterations):
+ """Run the service discovery latency test with the specified DW intervals.
+
+ Args:
+ results: Result array to be populated - will add results (not erase it)
+ do_unsolicited_passive: True for unsolicited/passive, False for
+ solicited/active.
+ dw_24ghz: DW interval in the 2.4GHz band.
+ dw_5ghz: DW interval in the 5GHz band.
+ """
+ key = "%s_dw24_%d_dw5_%d" % (
+ "unsolicited_passive"
+ if do_unsolicited_passive else "solicited_active", dw_24ghz, dw_5ghz)
+ results[key] = {}
+ results[key]["num_iterations"] = num_iterations
+
+ p_dut = self.android_devices[0]
+ p_dut.pretty_name = "Publisher"
+ s_dut = self.android_devices[1]
+ s_dut.pretty_name = "Subscriber"
+
+ # override the default DW configuration
+ autils.config_dw_all_modes(p_dut, dw_24ghz, dw_5ghz)
+ autils.config_dw_all_modes(s_dut, dw_24ghz, dw_5ghz)
+
+ # Publisher+Subscriber: attach and wait for confirmation
+ p_id = p_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(p_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ time.sleep(self.device_startup_offset)
+ s_id = s_dut.droid.wifiAwareAttach(False)
+ autils.wait_for_event(s_dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ # start publish
+ p_disc_event = self.start_discovery_session(
+ p_dut, p_id, True, aconsts.PUBLISH_TYPE_UNSOLICITED
+ if do_unsolicited_passive else aconsts.PUBLISH_TYPE_SOLICITED)
+
+ # wait for for devices to synchronize with each other - used so that first
+ # discovery isn't biased by synchronization.
+ time.sleep(self.WAIT_FOR_CLUSTER)
+
+ # loop, perform discovery, and collect latency information
+ latencies = []
+ failed_discoveries = 0
+ for i in range(num_iterations):
+ # start subscribe
+ s_disc_id, s_session_event = self.start_discovery_session(
+ s_dut, s_id, False, aconsts.SUBSCRIBE_TYPE_PASSIVE
+ if do_unsolicited_passive else aconsts.SUBSCRIBE_TYPE_ACTIVE)
+
+ # wait for discovery (allow for failures here since running lots of
+ # samples and would like to get the partial data even in the presence of
+ # errors)
+ try:
+ discovery_event = s_dut.ed.pop_event(
+ aconsts.SESSION_CB_ON_SERVICE_DISCOVERED, autils.EVENT_TIMEOUT)
+ except queue.Empty:
+ s_dut.log.info("[Subscriber] Timed out while waiting for "
+ "SESSION_CB_ON_SERVICE_DISCOVERED")
+ failed_discoveries = failed_discoveries + 1
+ continue
+ finally:
+ # destroy subscribe
+ s_dut.droid.wifiAwareDestroyDiscoverySession(s_disc_id)
+
+ # collect latency information
+ latencies.append(
+ discovery_event["data"][aconsts.SESSION_CB_KEY_TIMESTAMP_MS] -
+ s_session_event["data"][aconsts.SESSION_CB_KEY_TIMESTAMP_MS])
+ self.log.info("Latency #%d = %d" % (i, latencies[-1]))
+
+ autils.extract_stats(
+ s_dut,
+ data=latencies,
+ results=results[key],
+ key_prefix="",
+ log_prefix="Subscribe Session Discovery (%s, dw24=%d, dw5=%d)" %
+ ("Unsolicited/Passive"
+ if do_unsolicited_passive else "Solicited/Active", dw_24ghz, dw_5ghz))
+ results[key]["num_failed_discovery"] = failed_discoveries
+
+ # clean up
+ p_dut.droid.wifiAwareDestroyAll()
+ s_dut.droid.wifiAwareDestroyAll()
+
+ def run_message_latency(self, results, dw_24ghz, dw_5ghz, num_iterations):
+ """Run the message tx latency test with the specified DW intervals.
+
+ Args:
+ results: Result array to be populated - will add results (not erase it)
+ dw_24ghz: DW interval in the 2.4GHz band.
+ dw_5ghz: DW interval in the 5GHz band.
+ """
+ key = "dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
+ results[key] = {}
+ results[key]["num_iterations"] = num_iterations
+
+ p_dut = self.android_devices[0]
+ s_dut = self.android_devices[1]
+
+ # override the default DW configuration
+ autils.config_dw_all_modes(p_dut, dw_24ghz, dw_5ghz)
+ autils.config_dw_all_modes(s_dut, dw_24ghz, dw_5ghz)
+
+ # Start up a discovery session
+ (p_id, s_id, p_disc_id, s_disc_id,
+ peer_id_on_sub) = autils.create_discovery_pair(
+ 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)
+
+ latencies = []
+ failed_tx = 0
+ messages_rx = 0
+ missing_rx = 0
+ corrupted_rx = 0
+ for i in range(num_iterations):
+ # send message
+ msg_s2p = "Message Subscriber -> Publisher #%d" % i
+ next_msg_id = self.get_next_msg_id()
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, next_msg_id,
+ msg_s2p, 0)
+
+ # wait for Tx confirmation
+ try:
+ sub_tx_msg_event = s_dut.ed.pop_event(
+ aconsts.SESSION_CB_ON_MESSAGE_SENT, 2 * autils.EVENT_TIMEOUT)
+ latencies.append(
+ sub_tx_msg_event["data"][aconsts.SESSION_CB_KEY_LATENCY_MS])
+ except queue.Empty:
+ s_dut.log.info("[Subscriber] Timed out while waiting for "
+ "SESSION_CB_ON_MESSAGE_SENT")
+ failed_tx = failed_tx + 1
+ continue
+
+ # wait for Rx confirmation (and validate contents)
+ try:
+ pub_rx_msg_event = p_dut.ed.pop_event(
+ aconsts.SESSION_CB_ON_MESSAGE_RECEIVED, 2 * autils.EVENT_TIMEOUT)
+ messages_rx = messages_rx + 1
+ if (pub_rx_msg_event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING]
+ != msg_s2p):
+ corrupted_rx = corrupted_rx + 1
+ except queue.Empty:
+ s_dut.log.info("[Publisher] Timed out while waiting for "
+ "SESSION_CB_ON_MESSAGE_RECEIVED")
+ missing_rx = missing_rx + 1
+ continue
+
+ autils.extract_stats(
+ s_dut,
+ data=latencies,
+ results=results[key],
+ key_prefix="",
+ log_prefix="Subscribe Session Discovery (dw24=%d, dw5=%d)" %
+ (dw_24ghz, dw_5ghz))
+ results[key]["failed_tx"] = failed_tx
+ results[key]["messages_rx"] = messages_rx
+ results[key]["missing_rx"] = missing_rx
+ results[key]["corrupted_rx"] = corrupted_rx
+
+ # clean up
+ p_dut.droid.wifiAwareDestroyAll()
+ s_dut.droid.wifiAwareDestroyAll()
+
+ def run_ndp_oob_latency(self, results, dw_24ghz, dw_5ghz, num_iterations):
+ """Runs the NDP setup with OOB (out-of-band) discovery latency test.
+
+ Args:
+ results: Result array to be populated - will add results (not erase it)
+ dw_24ghz: DW interval in the 2.4GHz band.
+ dw_5ghz: DW interval in the 5GHz band.
+ """
+ key_avail = "on_avail_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
+ key_link_props = "link_props_dw24_%d_dw5_%d" % (dw_24ghz, dw_5ghz)
+ results[key_avail] = {}
+ results[key_link_props] = {}
+ results[key_avail]["num_iterations"] = num_iterations
+
+ init_dut = self.android_devices[0]
+ init_dut.pretty_name = 'Initiator'
+ resp_dut = self.android_devices[1]
+ resp_dut.pretty_name = 'Responder'
+
+ # override the default DW configuration
+ autils.config_dw_all_modes(init_dut, dw_24ghz, dw_5ghz)
+ autils.config_dw_all_modes(resp_dut, dw_24ghz, dw_5ghz)
+
+ # Initiator+Responder: attach and wait for confirmation & identity
+ init_id = init_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ init_ident_event = autils.wait_for_event(init_dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ init_mac = init_ident_event['data']['mac']
+ time.sleep(self.device_startup_offset)
+ resp_id = resp_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ resp_ident_event = autils.wait_for_event(resp_dut,
+ aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ resp_mac = resp_ident_event['data']['mac']
+
+ # wait for for devices to synchronize with each other - there are no other
+ # mechanisms to make sure this happens for OOB discovery (except retrying
+ # to execute the data-path request)
+ time.sleep(autils.WAIT_FOR_CLUSTER)
+
+ on_available_latencies = []
+ link_props_latencies = []
+ ndp_setup_failures = 0
+ for i in range(num_iterations):
+ # Responder: request network
+ resp_req_key = autils.request_network(
+ resp_dut,
+ resp_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None))
+
+ # Initiator: request network
+ init_req_key = autils.request_network(
+ init_dut,
+ init_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None))
+
+ # Initiator & Responder: wait for network formation
+ got_on_available = False
+ got_on_link_props = False
+ while not got_on_available or not got_on_link_props:
+ try:
+ nc_event = init_dut.ed.pop_event(cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT)
+ if nc_event["data"][
+ cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE:
+ got_on_available = True
+ on_available_latencies.append(
+ nc_event["data"][cconsts.NETWORK_CB_KEY_CURRENT_TS] -
+ nc_event["data"][cconsts.NETWORK_CB_KEY_CREATE_TS])
+ elif (nc_event["data"][cconsts.NETWORK_CB_KEY_EVENT] ==
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED):
+ got_on_link_props = True
+ link_props_latencies.append(
+ nc_event["data"][cconsts.NETWORK_CB_KEY_CURRENT_TS] -
+ nc_event["data"][cconsts.NETWORK_CB_KEY_CREATE_TS])
+ except queue.Empty:
+ ndp_setup_failures = ndp_setup_failures + 1
+ init_dut.log.info("[Initiator] Timed out while waiting for "
+ "EVENT_NETWORK_CALLBACK")
+ break
+
+ # clean-up
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+
+ # wait before trying another iteration (need to let CM clean-up)
+ time.sleep(10)
+
+ autils.extract_stats(
+ init_dut,
+ data=on_available_latencies,
+ results=results[key_avail],
+ key_prefix="",
+ log_prefix="NDP setup OnAvailable(dw24=%d, dw5=%d)" % (dw_24ghz,
+ dw_5ghz))
+ autils.extract_stats(
+ init_dut,
+ data=link_props_latencies,
+ results=results[key_link_props],
+ key_prefix="",
+ log_prefix="NDP setup OnLinkProperties (dw24=%d, dw5=%d)" % (dw_24ghz,
+ dw_5ghz))
+ results[key_avail]["ndp_setup_failures"] = ndp_setup_failures
+
+
+ ########################################################################
+
+ def test_synchronization_default_dws(self):
+ """Measure the device synchronization for default dws. Loop over values
+ from 0 to 4 seconds."""
+ results = {}
+ for startup_offset in range(5):
+ self.run_synchronization_latency(
+ results=results,
+ do_unsolicited_passive=True,
+ dw_24ghz=aconsts.DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=startup_offset,
+ timeout_period=20)
+ asserts.explicit_pass(
+ "test_synchronization_default_dws finished", extras=results)
+
+ def test_synchronization_non_interactive_dws(self):
+ """Measure the device synchronization for non-interactive dws. Loop over
+ values from 0 to 4 seconds."""
+ results = {}
+ for startup_offset in range(5):
+ self.run_synchronization_latency(
+ results=results,
+ do_unsolicited_passive=True,
+ dw_24ghz=aconsts.DW_24_NON_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_NON_INTERACTIVE,
+ num_iterations=10,
+ startup_offset=startup_offset,
+ timeout_period=20)
+ asserts.explicit_pass(
+ "test_synchronization_non_interactive_dws finished", extras=results)
+
+ def test_discovery_latency_default_dws(self):
+ """Measure the service discovery latency with the default DW configuration.
+ """
+ results = {}
+ self.run_discovery_latency(
+ results=results,
+ do_unsolicited_passive=True,
+ dw_24ghz=aconsts.DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_INTERACTIVE,
+ num_iterations=100)
+ asserts.explicit_pass(
+ "test_discovery_latency_default_parameters finished", extras=results)
+
+ def test_discovery_latency_non_interactive_dws(self):
+ """Measure the service discovery latency with the DW configuration for non
+ -interactive mode (lower power)."""
+ results = {}
+ self.run_discovery_latency(
+ results=results,
+ do_unsolicited_passive=True,
+ dw_24ghz=aconsts.DW_24_NON_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_NON_INTERACTIVE,
+ num_iterations=100)
+ asserts.explicit_pass(
+ "test_discovery_latency_non_interactive_dws finished", extras=results)
+
+ def test_discovery_latency_all_dws(self):
+ """Measure the service discovery latency with all DW combinations (low
+ iteration count)"""
+ results = {}
+ for dw24 in range(1, 6): # permitted values: 1-5
+ for dw5 in range(0, 6): # permitted values: 0, 1-5
+ self.run_discovery_latency(
+ results=results,
+ do_unsolicited_passive=True,
+ dw_24ghz=dw24,
+ dw_5ghz=dw5,
+ num_iterations=10)
+ asserts.explicit_pass(
+ "test_discovery_latency_all_dws finished", extras=results)
+
+ def test_message_latency_default_dws(self):
+ """Measure the send message latency with the default DW configuration. Test
+ performed on non-queued message transmission - i.e. waiting for confirmation
+ of reception (ACK) before sending the next message."""
+ results = {}
+ self.run_message_latency(
+ results=results,
+ dw_24ghz=aconsts.DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_INTERACTIVE,
+ num_iterations=100)
+ asserts.explicit_pass(
+ "test_message_latency_default_dws finished", extras=results)
+
+ def test_message_latency_non_interactive_dws(self):
+ """Measure the send message latency with the DW configuration for
+ non-interactive mode. Test performed on non-queued message transmission -
+ i.e. waiting for confirmation of reception (ACK) before sending the next
+ message."""
+ results = {}
+ self.run_message_latency(
+ results=results,
+ dw_24ghz=aconsts.DW_24_NON_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_NON_INTERACTIVE,
+ num_iterations=100)
+ asserts.explicit_pass(
+ "test_message_latency_non_interactive_dws finished", extras=results)
+
+ def test_oob_ndp_setup_latency_default_dws(self):
+ """Measure the NDP setup latency with the default DW configuration. The
+ NDP is setup with OOB (out-of-band) configuration."""
+ results = {}
+ self.run_ndp_oob_latency(
+ results=results,
+ dw_24ghz=aconsts.DW_24_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_INTERACTIVE,
+ num_iterations=10)
+ asserts.explicit_pass(
+ "test_ndp_setup_latency_default_dws finished", extras=results)
+
+ def test_oob_ndp_setup_latency_non_interactive_dws(self):
+ """Measure the NDP setup latency with the DW configuration for
+ non-interactive mode. The NDP is setup with OOB (out-of-band)
+ configuration"""
+ results = {}
+ self.run_ndp_oob_latency(
+ results=results,
+ dw_24ghz=aconsts.DW_24_NON_INTERACTIVE,
+ dw_5ghz=aconsts.DW_5_NON_INTERACTIVE,
+ num_iterations=10)
+ asserts.explicit_pass(
+ "test_ndp_setup_latency_non_interactive_dws finished", extras=results)
diff --git a/acts/tests/google/wifi/aware/performance/ThroughputTest.py b/acts/tests/google/wifi/aware/performance/ThroughputTest.py
new file mode 100644
index 0000000..fe2fd0c
--- /dev/null
+++ b/acts/tests/google/wifi/aware/performance/ThroughputTest.py
@@ -0,0 +1,116 @@
+#!/usr/bin/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 json
+import pprint
+import time
+
+from acts import asserts
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class ThroughputTest(AwareBaseTest):
+ """Set of tests for Wi-Fi Aware to measure latency of Aware operations."""
+
+ SERVICE_NAME = "GoogleTestServiceXYZ"
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def request_network(self, dut, ns):
+ """Request a Wi-Fi Aware network.
+
+ Args:
+ dut: Device
+ ns: Network specifier
+ Returns: the request key
+ """
+ network_req = {"TransportType": 5, "NetworkSpecifier": ns}
+ return dut.droid.connectivityRequestWifiAwareNetwork(network_req)
+
+ def run_iperf_single_ndp_aware_only(self, use_ib, results):
+ """Measure iperf performance on a single NDP, with Aware enabled and no
+ infrastructure connection - i.e. device is not associated to an AP.
+
+ Args:
+ use_ib: True to use in-band discovery, False to use out-of-band discovery.
+ results: Dictionary into which to place test results.
+ """
+ init_dut = self.android_devices[0]
+ resp_dut = self.android_devices[1]
+
+ if use_ib:
+ # note: Publisher = Responder, Subscribe = Initiator
+ (resp_req_key, init_req_key, resp_aware_if,
+ init_aware_if, resp_ipv6, init_ipv6) = autils.create_ib_ndp(
+ resp_dut, init_dut,
+ autils.create_discovery_config(self.SERVICE_NAME,
+ aconsts.PUBLISH_TYPE_UNSOLICITED),
+ autils.create_discovery_config(self.SERVICE_NAME,
+ aconsts.SUBSCRIBE_TYPE_PASSIVE),
+ self.device_startup_offset)
+ else:
+ (init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
+ resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
+ self.log.info("Interface names: I=%s, R=%s", init_aware_if, resp_aware_if)
+ self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
+ resp_ipv6)
+
+ # Run iperf3
+ result, data = init_dut.run_iperf_server("-D")
+ asserts.assert_true(result, "Can't start iperf3 server")
+
+ result, data = resp_dut.run_iperf_client(
+ "%s%%%s" % (init_ipv6, resp_aware_if), "-6 -J")
+ self.log.debug(data)
+ asserts.assert_true(result,
+ "Failure starting/running iperf3 in client mode")
+ self.log.debug(pprint.pformat(data))
+
+ # clean-up
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+
+ # Collect results
+ data_json = json.loads("".join(data))
+ if "error" in data_json:
+ asserts.fail(
+ "iperf run failed: %s" % data_json["error"], extras=data_json)
+ results["tx_rate"] = data_json["end"]["sum_sent"]["bits_per_second"]
+ results["rx_rate"] = data_json["end"]["sum_received"]["bits_per_second"]
+ self.log.info("iPerf3: Sent = %d bps Received = %d bps", results["tx_rate"],
+ results["rx_rate"])
+
+ ########################################################################
+
+ def test_iperf_single_ndp_aware_only_ib(self):
+ """Measure throughput using iperf on a single NDP, with Aware enabled and
+ no infrastructure connection. Use in-band discovery."""
+ results = {}
+ self.run_iperf_single_ndp_aware_only(use_ib=True, results=results)
+ asserts.explicit_pass(
+ "test_iperf_single_ndp_aware_only_ib passes", extras=results)
+
+ def test_iperf_single_ndp_aware_only_oob(self):
+ """Measure throughput using iperf on a single NDP, with Aware enabled and
+ no infrastructure connection. Use out-of-band discovery."""
+ results = {}
+ self.run_iperf_single_ndp_aware_only(use_ib=False, results=results)
+ asserts.explicit_pass(
+ "test_iperf_single_ndp_aware_only_ib passes", extras=results)
diff --git a/acts/tests/google/wifi/aware/performance/performance b/acts/tests/google/wifi/aware/performance/performance
new file mode 100644
index 0000000..17e3963
--- /dev/null
+++ b/acts/tests/google/wifi/aware/performance/performance
@@ -0,0 +1,2 @@
+LatencyTest
+ThroughputTest
\ No newline at end of file
diff --git a/acts/tests/google/wifi/aware/stress/DataPathStressTest.py b/acts/tests/google/wifi/aware/stress/DataPathStressTest.py
new file mode 100644
index 0000000..ab204b6
--- /dev/null
+++ b/acts/tests/google/wifi/aware/stress/DataPathStressTest.py
@@ -0,0 +1,149 @@
+#!/usr/bin/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 queue
+import time
+
+from acts import asserts
+from acts.test_utils.net import connectivity_const as cconsts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class DataPathStressTest(AwareBaseTest):
+
+ # Number of iterations on create/destroy Attach sessions.
+ ATTACH_ITERATIONS = 2
+
+ # Number of iterations on create/destroy NDP in each discovery session.
+ NDP_ITERATIONS = 5
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ ################################################################
+
+ def test_oob_ndp_stress(self):
+ """Run NDP (NAN data-path) stress test creating and destroying Aware
+ attach sessions, discovery sessions, and NDPs."""
+ init_dut = self.android_devices[0]
+ init_dut.pretty_name = 'Initiator'
+ resp_dut = self.android_devices[1]
+ resp_dut.pretty_name = 'Responder'
+
+ ndp_init_setup_success = 0
+ ndp_init_setup_failures = 0
+ ndp_resp_setup_success = 0
+ ndp_resp_setup_failures = 0
+
+ for attach_iter in range(self.ATTACH_ITERATIONS):
+ init_id = init_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(init_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ init_ident_event = autils.wait_for_event(
+ init_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ init_mac = init_ident_event['data']['mac']
+ time.sleep(self.device_startup_offset)
+ resp_id = resp_dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(resp_dut, aconsts.EVENT_CB_ON_ATTACHED)
+ resp_ident_event = autils.wait_for_event(
+ resp_dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
+ resp_mac = resp_ident_event['data']['mac']
+
+ # wait for for devices to synchronize with each other - there are no other
+ # mechanisms to make sure this happens for OOB discovery (except retrying
+ # to execute the data-path request)
+ time.sleep(autils.WAIT_FOR_CLUSTER)
+
+ for ndp_iteration in range(self.NDP_ITERATIONS):
+ # Responder: request network
+ resp_req_key = autils.request_network(
+ resp_dut,
+ resp_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ resp_id, aconsts.DATA_PATH_RESPONDER, init_mac, None))
+
+ # Initiator: request network
+ init_req_key = autils.request_network(
+ init_dut,
+ init_dut.droid.wifiAwareCreateNetworkSpecifierOob(
+ init_id, aconsts.DATA_PATH_INITIATOR, resp_mac, None))
+
+ # Initiator: wait for network formation
+ got_on_available = False
+ got_on_link_props = False
+ while not got_on_available or not got_on_link_props:
+ try:
+ nc_event = init_dut.ed.pop_event(cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT)
+ if nc_event['data'][
+ cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE:
+ got_on_available = True
+ elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] ==
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED):
+ got_on_link_props = True
+ except queue.Empty:
+ ndp_init_setup_failures = ndp_init_setup_failures + 1
+ init_dut.log.info('[Initiator] Timed out while waiting for '
+ 'EVENT_NETWORK_CALLBACK')
+ break
+
+ if got_on_available and got_on_link_props:
+ ndp_init_setup_success = ndp_init_setup_success + 1
+
+ # Responder: wait for network formation
+ got_on_available = False
+ got_on_link_props = False
+ while not got_on_available or not got_on_link_props:
+ try:
+ nc_event = resp_dut.ed.pop_event(cconsts.EVENT_NETWORK_CALLBACK,
+ autils.EVENT_NDP_TIMEOUT)
+ if nc_event['data'][
+ cconsts.NETWORK_CB_KEY_EVENT] == cconsts.NETWORK_CB_AVAILABLE:
+ got_on_available = True
+ elif (nc_event['data'][cconsts.NETWORK_CB_KEY_EVENT] ==
+ cconsts.NETWORK_CB_LINK_PROPERTIES_CHANGED):
+ got_on_link_props = True
+ except queue.Empty:
+ ndp_resp_setup_failures = ndp_resp_setup_failures + 1
+ init_dut.log.info('[Responder] Timed out while waiting for '
+ 'EVENT_NETWORK_CALLBACK')
+ break
+
+ if got_on_available and got_on_link_props:
+ ndp_resp_setup_success = ndp_resp_setup_success + 1
+
+ # clean-up
+ init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
+ resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
+
+ # wait before trying another iteration (need to let CM clean-up)
+ time.sleep(10)
+
+ # clean-up at end of iteration
+ init_dut.droid.wifiAwareDestroy(init_id)
+ resp_dut.droid.wifiAwareDestroy(resp_id)
+
+ results = {}
+ results['ndp_init_setup_success'] = ndp_init_setup_success
+ results['ndp_init_setup_failures'] = ndp_init_setup_failures
+ results['ndp_resp_setup_success'] = ndp_resp_setup_success
+ results['ndp_resp_setup_failures'] = ndp_resp_setup_failures
+ asserts.assert_equal(
+ ndp_init_setup_failures + ndp_resp_setup_failures,
+ 0,
+ 'test_oob_ndp_stress finished',
+ extras=results)
+ asserts.explicit_pass("test_oob_ndp_stress done", extras=results)
diff --git a/acts/tests/google/wifi/aware/stress/DiscoveryStressTest.py b/acts/tests/google/wifi/aware/stress/DiscoveryStressTest.py
new file mode 100644
index 0000000..8b3d925
--- /dev/null
+++ b/acts/tests/google/wifi/aware/stress/DiscoveryStressTest.py
@@ -0,0 +1,109 @@
+#!/usr/bin/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 queue
+import time
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+
+class DiscoveryStressTest(AwareBaseTest):
+ """Stress tests for Discovery sessions"""
+
+ # Number of iterations on create/destroy Attach sessions.
+ ATTACH_ITERATIONS = 2
+
+ # Number of iterations on create/destroy Discovery sessions
+ DISCOVERY_ITERATIONS = 40
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ ####################################################################
+
+ def test_discovery_stress(self):
+ """Create and destroy a random array of discovery sessions, up to the
+ limit of capabilities."""
+ dut = self.android_devices[0]
+
+ discovery_setup_success = 0
+ discovery_setup_fail = 0
+
+ for attach_iter in range(self.ATTACH_ITERATIONS):
+ # attach
+ session_id = dut.droid.wifiAwareAttach(True)
+ autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
+
+ p_discovery_ids = []
+ s_discovery_ids = []
+ for discovery_iter in range(self.DISCOVERY_ITERATIONS):
+ service_name = 'GoogleTestService-%d-%d' % (attach_iter, discovery_iter)
+
+ p_config = None
+ s_config = None
+
+ if discovery_iter % 4 == 0: # publish/unsolicited
+ p_config = autils.create_discovery_config(
+ service_name, aconsts.PUBLISH_TYPE_UNSOLICITED)
+ elif discovery_iter % 4 == 1: # publish/solicited
+ p_config = autils.create_discovery_config(
+ service_name, aconsts.PUBLISH_TYPE_SOLICITED)
+ elif discovery_iter % 4 == 2: # subscribe/passive
+ s_config = autils.create_discovery_config(
+ service_name, aconsts.SUBSCRIBE_TYPE_PASSIVE)
+ elif discovery_iter % 4 == 3: # subscribe/active
+ s_config = autils.create_discovery_config(
+ service_name, aconsts.SUBSCRIBE_TYPE_ACTIVE)
+
+ if p_config is not None:
+ if len(p_discovery_ids) == dut.aware_capabilities[
+ aconsts.CAP_MAX_PUBLISHES]:
+ dut.droid.wifiAwareDestroyDiscoverySession(
+ p_discovery_ids.pop(dut.aware_capabilities[
+ aconsts.CAP_MAX_PUBLISHES] // 2))
+ disc_id = dut.droid.wifiAwarePublish(session_id, p_config)
+ event_name = aconsts.SESSION_CB_ON_PUBLISH_STARTED
+ p_discovery_ids.append(disc_id)
+ else:
+ if len(s_discovery_ids) == dut.aware_capabilities[
+ aconsts.CAP_MAX_SUBSCRIBES]:
+ dut.droid.wifiAwareDestroyDiscoverySession(
+ s_discovery_ids.pop(dut.aware_capabilities[
+ aconsts.CAP_MAX_SUBSCRIBES] // 2))
+ disc_id = dut.droid.wifiAwareSubscribe(session_id, s_config)
+ event_name = aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED
+ s_discovery_ids.append(disc_id)
+
+ try:
+ dut.ed.pop_event(event_name, autils.EVENT_TIMEOUT)
+ discovery_setup_success = discovery_setup_success + 1
+ except queue.Empty:
+ discovery_setup_fail = discovery_setup_fail + 1
+
+ dut.droid.wifiAwareDestroy(session_id)
+
+ results = {}
+ results['discovery_setup_success'] = discovery_setup_success
+ results['discovery_setup_fail'] = discovery_setup_fail
+ asserts.assert_equal(
+ discovery_setup_fail,
+ 0,
+ 'test_discovery_stress finished',
+ extras=results)
+ asserts.explicit_pass('test_discovery_stress done', extras=results)
diff --git a/acts/tests/google/wifi/aware/stress/MessagesStressTest.py b/acts/tests/google/wifi/aware/stress/MessagesStressTest.py
new file mode 100644
index 0000000..5871d61
--- /dev/null
+++ b/acts/tests/google/wifi/aware/stress/MessagesStressTest.py
@@ -0,0 +1,269 @@
+#!/usr/bin/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 queue
+
+from acts import asserts
+from acts.test_utils.wifi.aware import aware_const as aconsts
+from acts.test_utils.wifi.aware import aware_test_utils as autils
+from acts.test_utils.wifi.aware.AwareBaseTest import AwareBaseTest
+
+KEY_ID = "id"
+KEY_TX_OK_COUNT = "tx_ok_count"
+KEY_TX_FAIL_COUNT = "tx_fail_count"
+KEY_RX_COUNT = "rx_count"
+
+
+class MessagesStressTest(AwareBaseTest):
+ """Set of stress tests for Wi-Fi Aware L2 (layer 2) message exchanges."""
+ NUM_ITERATIONS = 100
+ SERVICE_NAME = "GoogleTestServiceXY"
+
+ def __init__(self, controllers):
+ AwareBaseTest.__init__(self, controllers)
+
+ def init_info(self, msg, id, messages_by_msg, messages_by_id):
+ """Initialize the message data structures.
+
+ Args:
+ msg: message text
+ id: message id
+ messages_by_msg: {text -> {id, tx_ok_count, tx_fail_count, rx_count}}
+ messages_by_id: {id -> text}
+ """
+ messages_by_msg[msg] = {}
+ messages_by_msg[msg][KEY_ID] = id
+ messages_by_msg[msg][KEY_TX_OK_COUNT] = 0
+ messages_by_msg[msg][KEY_TX_FAIL_COUNT] = 0
+ messages_by_msg[msg][KEY_RX_COUNT] = 0
+ messages_by_id[id] = msg
+
+ def wait_for_tx_events(self, dut, num_msgs, messages_by_msg, messages_by_id):
+ """Wait for messages to be transmitted and update data structures.
+
+ Args:
+ dut: device under test
+ num_msgs: number of expected message tx
+ messages_by_msg: {text -> {id, tx_ok_count, tx_fail_count, rx_count}}
+ messages_by_id: {id -> text}
+ """
+ num_ok_tx_confirmations = 0
+ num_fail_tx_confirmations = 0
+ num_unexpected_ids = 0
+ tx_events_regex = "%s|%s" % (aconsts.SESSION_CB_ON_MESSAGE_SEND_FAILED,
+ aconsts.SESSION_CB_ON_MESSAGE_SENT)
+ while num_ok_tx_confirmations + num_fail_tx_confirmations < num_msgs:
+ try:
+ events = dut.ed.pop_events(tx_events_regex, autils.EVENT_TIMEOUT)
+ for event in events:
+ if (event["name"] != aconsts.SESSION_CB_ON_MESSAGE_SENT and
+ event["name"] != aconsts.SESSION_CB_ON_MESSAGE_SEND_FAILED):
+ asserts.fail("Unexpected event: %s" % event)
+ is_tx_ok = event["name"] == aconsts.SESSION_CB_ON_MESSAGE_SENT
+
+ id = event["data"][aconsts.SESSION_CB_KEY_MESSAGE_ID]
+ if id in messages_by_id:
+ msg = messages_by_id[id]
+ if is_tx_ok:
+ messages_by_msg[msg][
+ KEY_TX_OK_COUNT] = messages_by_msg[msg][KEY_TX_OK_COUNT] + 1
+ if messages_by_msg[msg][KEY_TX_OK_COUNT] == 1:
+ num_ok_tx_confirmations = num_ok_tx_confirmations + 1
+ else:
+ messages_by_msg[msg][KEY_TX_FAIL_COUNT] = (
+ messages_by_msg[msg][KEY_TX_FAIL_COUNT] + 1)
+ if messages_by_msg[msg][KEY_TX_FAIL_COUNT] == 1:
+ num_fail_tx_confirmations = num_fail_tx_confirmations + 1
+ else:
+ self.log.warning(
+ "Tx confirmation of unknown message ID received: %s", event)
+ num_unexpected_ids = num_unexpected_ids + 1
+ except queue.Empty:
+ self.log.warning("[%s] Timed out waiting for any MESSAGE_SEND* event - "
+ "assuming the rest are not coming", dut.pretty_name)
+ break
+
+ return (num_ok_tx_confirmations, num_fail_tx_confirmations,
+ num_unexpected_ids)
+
+ def wait_for_rx_events(self, dut, num_msgs, messages_by_msg):
+ """Wait for messages to be received and update data structures
+
+ Args:
+ dut: device under test
+ num_msgs: number of expected messages to receive
+ messages_by_msg: {text -> {id, tx_ok_count, tx_fail_count, rx_count}}
+ """
+ num_rx_msgs = 0
+ while num_rx_msgs < num_msgs:
+ try:
+ event = dut.ed.pop_event(aconsts.SESSION_CB_ON_MESSAGE_RECEIVED,
+ autils.EVENT_TIMEOUT)
+ msg = event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING]
+ if msg not in messages_by_msg:
+ messages_by_msg[msg] = {}
+ messages_by_msg[msg][KEY_ID] = -1
+ messages_by_msg[msg][KEY_TX_OK_COUNT] = 0
+ messages_by_msg[msg][KEY_TX_FAIL_COUNT] = 0
+ messages_by_msg[msg][KEY_RX_COUNT] = 1
+
+ messages_by_msg[msg][
+ KEY_RX_COUNT] = messages_by_msg[msg][KEY_RX_COUNT] + 1
+ if messages_by_msg[msg][KEY_RX_COUNT] == 1:
+ num_rx_msgs = num_rx_msgs + 1
+ except queue.Empty:
+ self.log.warning(
+ "[%s] Timed out waiting for ON_MESSAGE_RECEIVED event - "
+ "assuming the rest are not coming", dut.pretty_name)
+ break
+
+ def analyze_results(self, results, messages_by_msg):
+ """Analyze the results of the stress message test and add to the results
+ dictionary
+
+ Args:
+ results: result dictionary into which to add data
+ messages_by_msg: {text -> {id, tx_ok_count, tx_fail_count, rx_count}}
+ """
+ results["raw_data"] = messages_by_msg
+ results["tx_count_success"] = 0
+ results["tx_count_duplicate_success"] = 0
+ results["tx_count_fail"] = 0
+ results["tx_count_duplicate_fail"] = 0
+ results["tx_count_neither"] = 0
+ results["tx_count_tx_ok_but_no_rx"] = 0
+ results["rx_count"] = 0
+ results["rx_count_duplicate"] = 0
+ results["rx_count_no_ok_tx_indication"] = 0
+ results["rx_count_fail_tx_indication"] = 0
+ results["rx_count_no_tx_message"] = 0
+
+ for msg, data in messages_by_msg.items():
+ if data[KEY_TX_OK_COUNT] > 0:
+ results["tx_count_success"] = results["tx_count_success"] + 1
+ if data[KEY_TX_OK_COUNT] > 1:
+ results["tx_count_duplicate_success"] = (
+ results["tx_count_duplicate_success"] + 1)
+ if data[KEY_TX_FAIL_COUNT] > 0:
+ results["tx_count_fail"] = results["tx_count_fail"] + 1
+ if data[KEY_TX_FAIL_COUNT] > 1:
+ results[
+ "tx_count_duplicate_fail"] = results["tx_count_duplicate_fail"] + 1
+ if (data[KEY_TX_OK_COUNT] == 0 and data[KEY_TX_FAIL_COUNT] == 0 and
+ data[KEY_ID] != -1):
+ results["tx_count_neither"] = results["tx_count_neither"] + 1
+ if data[KEY_TX_OK_COUNT] > 0 and data[KEY_RX_COUNT] == 0:
+ results["tx_count_tx_ok_but_no_rx"] = (
+ results["tx_count_tx_ok_but_no_rx"] + 1)
+ if data[KEY_RX_COUNT] > 0:
+ results["rx_count"] = results["rx_count"] + 1
+ if data[KEY_RX_COUNT] > 1:
+ results["rx_count_duplicate"] = results["rx_count_duplicate"] + 1
+ if data[KEY_RX_COUNT] > 0 and data[KEY_TX_OK_COUNT] == 0:
+ results["rx_count_no_ok_tx_indication"] = (
+ results["rx_count_no_ok_tx_indication"] + 1)
+ if data[KEY_RX_COUNT] > 0 and data[KEY_TX_FAIL_COUNT] > 0:
+ results["rx_count_fail_tx_indication"] = (
+ results["rx_count_fail_tx_indication"] + 1)
+ if data[KEY_RX_COUNT] > 0 and data[KEY_ID] == -1:
+ results[
+ "rx_count_no_tx_message"] = results["rx_count_no_tx_message"] + 1
+
+ #######################################################################
+
+ def test_stress_message(self):
+ """Stress test for bi-directional message transmission and reception."""
+ p_dut = self.android_devices[0]
+ s_dut = self.android_devices[1]
+
+ # Start up a discovery session
+ discovery_data = autils.create_discovery_pair(
+ 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,
+ msg_id=self.get_next_msg_id())
+ p_id = discovery_data[0]
+ s_id = discovery_data[1]
+ p_disc_id = discovery_data[2]
+ s_disc_id = discovery_data[3]
+ peer_id_on_sub = discovery_data[4]
+ peer_id_on_pub = discovery_data[5]
+
+ # Store information on Tx & Rx messages
+ messages_by_msg = {} # keyed by message text
+ # {text -> {id, tx_ok_count, tx_fail_count, rx_count}}
+ messages_by_id = {} # keyed by message ID {id -> text}
+
+ # send all messages at once (one in each direction)
+ for i in range(self.NUM_ITERATIONS):
+ msg_p2s = "Message Publisher -> Subscriber #%d" % i
+ next_msg_id = self.get_next_msg_id()
+ self.init_info(msg_p2s, next_msg_id, messages_by_msg, messages_by_id)
+ p_dut.droid.wifiAwareSendMessage(p_disc_id, peer_id_on_pub, next_msg_id,
+ msg_p2s, 0)
+
+ msg_s2p = "Message Subscriber -> Publisher #%d" % i
+ next_msg_id = self.get_next_msg_id()
+ self.init_info(msg_s2p, next_msg_id, messages_by_msg, messages_by_id)
+ s_dut.droid.wifiAwareSendMessage(s_disc_id, peer_id_on_sub, next_msg_id,
+ msg_s2p, 0)
+
+ # wait for message tx confirmation
+ (p_tx_ok_count, p_tx_fail_count, p_tx_unknown_id) = self.wait_for_tx_events(
+ p_dut, self.NUM_ITERATIONS, messages_by_msg, messages_by_id)
+ (s_tx_ok_count, s_tx_fail_count, s_tx_unknown_id) = self.wait_for_tx_events(
+ s_dut, self.NUM_ITERATIONS, messages_by_msg, messages_by_id)
+ self.log.info("Transmission done: pub=%d, sub=%d transmitted successfully",
+ p_tx_ok_count, s_tx_ok_count)
+
+ # wait for message rx confirmation (giving it the total number of messages
+ # transmitted rather than just those transmitted correctly since sometimes
+ # the Tx doesn't get that information correctly. I.e. a message the Tx
+ # thought was not transmitted correctly is actually received - missing ACK?
+ # bug?)
+ self.wait_for_rx_events(p_dut, self.NUM_ITERATIONS, messages_by_msg)
+ self.wait_for_rx_events(s_dut, self.NUM_ITERATIONS, messages_by_msg)
+
+ # analyze results
+ results = {}
+ results["tx_count"] = 2 * self.NUM_ITERATIONS
+ results["tx_unknown_ids"] = p_tx_unknown_id + s_tx_unknown_id
+ self.analyze_results(results, messages_by_msg)
+
+ # clear errors
+ asserts.assert_equal(results["tx_unknown_ids"], 0, "Message ID corruption",
+ results)
+ asserts.assert_equal(results["tx_count_duplicate_fail"], 0,
+ "Duplicate Tx fail messages", results)
+ asserts.assert_equal(results["tx_count_duplicate_success"], 0,
+ "Duplicate Tx success messages", results)
+ asserts.assert_equal(results["rx_count_no_tx_message"], 0,
+ "Rx message which wasn't sent - message corruption?",
+ results)
+ asserts.assert_equal(results["tx_count_tx_ok_but_no_rx"], 0,
+ "Tx got ACK but Rx didn't get message", results)
+
+ # possibly ok - but flag since most frequently a bug
+ asserts.assert_equal(results["rx_count_no_ok_tx_indication"], 0,
+ "Message received but Tx didn't get ACK", results)
+ asserts.assert_equal(results["rx_count_fail_tx_indication"], 0,
+ "Message received but Tx didn't get ACK", results)
+
+ asserts.explicit_pass("test_stress_message done", extras=results)
diff --git a/acts/tests/google/wifi/aware/stress/stress b/acts/tests/google/wifi/aware/stress/stress
new file mode 100644
index 0000000..0860507
--- /dev/null
+++ b/acts/tests/google/wifi/aware/stress/stress
@@ -0,0 +1,3 @@
+MessagesStressTest
+DataPathStressTest
+DiscoveryStressTest
\ No newline at end of file
diff --git a/acts/tests/sample/RelayDeviceSampleTest.py b/acts/tests/sample/RelayDeviceSampleTest.py
old mode 100755
new mode 100644
index e4622ed..040ef62
--- a/acts/tests/sample/RelayDeviceSampleTest.py
+++ b/acts/tests/sample/RelayDeviceSampleTest.py
@@ -17,6 +17,7 @@
from acts import test_runner
from acts.controllers.relay_lib.relay import SynchronizeRelays
+
class RelayDeviceSampleTest(base_test.BaseTestClass):
""" Demonstrates example usage of a configurable access point."""
@@ -27,7 +28,7 @@
# You can use this workaround to get devices by name:
relay_rig = self.relay_devices[0].rig
- #self.other_relay_device = relay_rig.devices['UniqueDeviceName']
+ self.other_relay_device = relay_rig.devices['UniqueDeviceName']
# Note: If the "devices" key from the config is missing
# a GenericRelayDevice that contains every switch in the config
# will be stored in relay_devices[0]. Its name will be
@@ -43,13 +44,61 @@
# Unless overridden, the default state is all switches set to off.
self.relay_device.clean_up()
+ # Typical use of a GenericRelayDevice looks like this:
+ def test_relay_device(self):
+
+ # This function call will sleep until .25 seconds are up.
+ # Blocking_nc_for will emulate a button press, which turns on the relay
+ # (or stays on if it already was on) for the given time, and then turns
+ # off.
+ self.relay_device.relays['BT_Power_Button'].set_nc_for(.25)
+
+ # do_something_after_turning_on_bt_power()
+
+ # Note that the relays are mechanical switches, and do take real time
+ # to go from one state to the next.
+
+ self.relay_device.relays['BT_Pair'].set_nc()
+
+ # do_something_while_holding_down_the_pair_button()
+
+ self.relay_device.relays['BT_Pair'].set_no()
+
+ # do_something_after_releasing_bt_pair()
+
+ # Note that although cleanup sets the relays to the 'NO' state after
+ # each test, they do not press things like the power button to turn
+ # off whatever hardware is attached. When using a GenericRelayDevice,
+ # you'll have to do this manually.
+ # Other RelayDevices may handle this for you in their clean_up() call.
+ self.relay_device.relays['BT_Power_Button'].set_nc_for(.25)
def test_toggling(self):
# This test just spams the toggle on each relay.
- ## print(self.relay_device.relays.mac_address)
- print("--->" + self.relay_device.mac_address + "<---")
for _ in range(0, 2):
- self.relay_device.relays['Play'].toggle()
+ self.relay_device.relays['BT_Power_Button'].toggle()
+ self.relay_device.relays['BT_Pair'].toggle()
+ self.relay_device.relays['BT_Reset'].toggle()
+ self.relay_device.relays['BT_SomethingElse'].toggle()
+
+ def test_synchronize_relays(self):
+ """Toggles relays using SynchronizeRelays().
+
+ This makes each relay do it's action at the same time, without waiting
+ after each relay to swap. Instead, all relays swap at the same time, and
+ the wait is done after exiting the with statement.
+ """
+ for _ in range(0, 10):
+ with SynchronizeRelays():
+ self.relay_device.relays['BT_Power_Button'].toggle()
+ self.relay_device.relays['BT_Pair'].toggle()
+ self.relay_device.relays['BT_Reset'].toggle()
+ self.relay_device.relays['BT_SomethingElse'].toggle()
+
+ # For more fine control over the wait time of relays, you can set
+ # Relay.transition_wait_time. This is not recommended unless you are
+ # using solid state relays, or async calls.
+
if __name__ == "__main__":
test_runner.main()
diff --git a/tools/.gitignore b/tools/.gitignore
new file mode 100644
index 0000000..c436601
--- /dev/null
+++ b/tools/.gitignore
@@ -0,0 +1,67 @@
+.DS_Store
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+#Ipython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
diff --git a/tools/commit_message_check.py b/tools/commit_message_check.py
new file mode 100755
index 0000000..092c18a
--- /dev/null
+++ b/tools/commit_message_check.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+#
+# 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.
+from __future__ import print_function
+
+import logging
+import os
+import re
+import sys
+
+from acts.libs.proc import job
+
+GLOBAL_KEYWORDS_FILEPATH = 'vendor/google_testing/comms/framework/etc/' \
+ 'commit_keywords'
+LOCAL_KEYWORDS_FILEPATH = '~/.repo_acts_commit_keywords'
+
+FIND_COMMIT_KEYWORDS = 'git log @{u}..| grep -i %s'
+GET_EMAIL_ADDRESS = 'git log --format=%ce -1'
+
+
+def main(argv):
+ file_path = os.path.join(
+ os.path.dirname(__file__), "../../../../%s" % GLOBAL_KEYWORDS_FILEPATH)
+
+ if not os.path.isfile(file_path):
+ file_path = os.path.expanduser(LOCAL_KEYWORDS_FILEPATH)
+ if not os.path.exists(file_path) or not os.path.isfile(file_path):
+ result = job.run(GET_EMAIL_ADDRESS)
+ if result.stdout.endswith('@google.com'):
+ logging.error(
+ 'You do not have the necessary file %s. Please run '
+ 'tools/ignore_commit_keywords.sh, or link it with the '
+ 'following command:\n ln -sf <internal_master_root>/%s %s'
+ % (LOCAL_KEYWORDS_FILEPATH, GLOBAL_KEYWORDS_FILEPATH,
+ LOCAL_KEYWORDS_FILEPATH))
+ exit(1)
+ return
+
+ with open(file_path) as file:
+ # Places every line within quotes with -e before them.
+ # i.e. '-e "line1" -e "line2" -e "line3"'
+ grep_args = re.sub('^(.+?)$\n?', ' -e "\\1"',
+ file.read(), 0, re.MULTILINE)
+
+ result = job.run(FIND_COMMIT_KEYWORDS % grep_args, ignore_status=True)
+
+ if result.stdout:
+ logging.error('Your commit message contains at least one keyword.')
+ logging.error('Keyword(s) found in the following line(s):')
+ logging.error(result.stdout)
+ logging.error('Please fix/remove these before committing.')
+ exit(1)
+
+
+if __name__ == '__main__':
+ main(sys.argv[1:])
diff --git a/tools/ignore_commit_keywords.sh b/tools/ignore_commit_keywords.sh
new file mode 100755
index 0000000..3a564b8
--- /dev/null
+++ b/tools/ignore_commit_keywords.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+#
+# Copyright 2016 - 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.
+
+touch ~/.repo_acts_commit_keywords
+echo "Ignoring repo commit keywords list."
diff --git a/tools/lab/README.md b/tools/lab/README.md
new file mode 100644
index 0000000..0b2ebbb
--- /dev/null
+++ b/tools/lab/README.md
@@ -0,0 +1 @@
+This folder contains tools to be used in the testing lab.
diff --git a/tools/lab/main.py b/tools/lab/main.py
new file mode 100755
index 0000000..873f682
--- /dev/null
+++ b/tools/lab/main.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+#
+# 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import argparse
+import sys
+
+from runner import InstantRunner
+from metrics.usb_metric import UsbMetric
+from reporter import LoggerReporter
+
+
+class RunnerFactory(object):
+ _reporter_constructor = {
+ 'logger': lambda: LoggerReporter(),
+ }
+
+ _metric_constructor = {
+ 'usb_io': lambda param: UsbMetric(),
+ 'disk': lambda param: DiskMetric(),
+ 'uptime': lambda param: UptimeMetric(),
+ 'verify_devices': lambda param: VerifyMetric(),
+ 'ram': lambda param: RamMetric(),
+ 'cpu': lambda param: CpuMetric(),
+ }
+
+ @classmethod
+ def create(cls, arguments):
+ """ Creates the Runner Class that will take care of gather metrics
+ and determining how to report those metrics.
+
+ Args:
+ arguments: The arguments passed in through command line, a dict.
+
+ Returns:
+ Returns a Runner that was created by passing in a list of
+ metrics and list of reporters.
+ """
+ arg_dict = arguments
+ metrics = []
+
+ # If no reporter specified, default to logger.
+ reporters = arg_dict.pop('reporter')
+ if reporters is None:
+ reporters = ['logger']
+
+ # Check keys and values to see what metrics to include.
+ for key in arg_dict:
+ val = arg_dict[key]
+ if val is not None:
+ metrics.append(cls._metric_constructor[key](val))
+
+ return InstantRunner(metrics, reporters)
+
+
+def _argparse():
+ parser = argparse.ArgumentParser(
+ description='Tool for getting lab health of android testing lab',
+ prog='Lab Health')
+
+ parser.add_argument(
+ '-v',
+ '--version',
+ action='version',
+ version='%(prog)s v0.1.0',
+ help='specify version of program')
+ parser.add_argument(
+ '-i',
+ '--usb-io',
+ action='store_true',
+ default=None,
+ help='display recent USB I/O')
+ parser.add_argument(
+ '-u',
+ '--uptime',
+ action='store_true',
+ default=None,
+ help='display uptime of current lab station')
+ parser.add_argument(
+ '-d',
+ '--disk',
+ choices=['size', 'used', 'avail', 'percent'],
+ nargs='*',
+ help='display the disk space statistics')
+ parser.add_argument(
+ '-ra',
+ '--ram',
+ action='store_true',
+ default=None,
+ help='display the current RAM usage')
+ parser.add_argument(
+ '-c',
+ '--cpu',
+ action='count',
+ default=None,
+ help='display the current CPU usage as percent')
+ parser.add_argument(
+ '-vd',
+ '--verify-devices',
+ action='store_true',
+ default=None,
+ help='verify all devices connected are in \'device\' mode')
+ parser.add_argument(
+ '-r',
+ '--reporter',
+ choices=['logger', 'proto', 'json'],
+ nargs='+',
+ help='choose the reporting method needed')
+ parser.add_argument(
+ '-p',
+ '--program',
+ choices=['python', 'adb', 'fastboot', 'os', 'kernel'],
+ nargs='*',
+ help='display the versions of chosen programs (default = all)')
+
+ return parser
+
+
+def main():
+ parser = _argparse()
+
+ if len(sys.argv) == 1:
+ parser.print_help()
+ sys.exit(1)
+
+ RunnerFactory().create(vars(parser.parse_args()))
+
+
+if __name__ == '__main__':
+ main()
diff --git a/tools/lab/main_test.py b/tools/lab/main_test.py
new file mode 100644
index 0000000..366767f
--- /dev/null
+++ b/tools/lab/main_test.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+#
+# 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 unittest
+
+from main import RunnerFactory
+from metrics.usb_metric import UsbMetric
+
+
+class RunnerFactoryTestCase(unittest.TestCase):
+ def test_create_with_reporter(self):
+ self.assertEqual(
+ RunnerFactory.create({
+ 'reporter': ['proto']
+ }).reporter_list, ['proto'])
+
+ def test_create_without_reporter(self):
+ self.assertEqual(
+ RunnerFactory.create({
+ 'reporter': None
+ }).reporter_list, ['logger'])
+
+ def test_metric_none(self):
+ self.assertEqual(
+ RunnerFactory.create({
+ 'disk': None,
+ 'reporter': None
+ }).metric_list, [])
+
+ def test_metric_true(self):
+ self.assertIsInstance(
+ RunnerFactory.create({
+ 'usb_io': True,
+ 'reporter': None
+ }).metric_list[0], UsbMetric)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tools/lab/metrics/__init__.py b/tools/lab/metrics/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/lab/metrics/__init__.py
diff --git a/tools/lab/metrics/disk_metric.py b/tools/lab/metrics/disk_metric.py
new file mode 100644
index 0000000..8357b42
--- /dev/null
+++ b/tools/lab/metrics/disk_metric.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+#
+# 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 metric
+
+
+class DiskMetric(metric.Metric):
+
+ COMMAND = "df /var/tmp"
+ # Fields for response dictionary
+ TOTAL = 'total'
+ USED = 'used'
+ AVAIL = 'avail'
+ PERCENT_USED = 'percent_used'
+
+ def gather_metric(self):
+ """Finds disk space metrics for /var/tmp
+
+ Returns:
+ A dict with the following fields:
+ total: int representing total space in 1k blocks
+ used: int representing total used in 1k blocks
+ avail: int representing total available in 1k blocks
+ percent_used: int representing percentage space used (0-100)
+ """
+ # Run shell command
+ result = self._shell.run(self.COMMAND)
+ """Example stdout:
+ Filesystem 1K-blocks Used Available Use% Mounted on
+ /dev/dm-1 57542652 18358676 36237928 34% /
+ """
+ # Get only second line
+ output = result.stdout.splitlines()[1]
+ # Split by space
+ fields = output.split()
+ # Create response dictionary
+ response = {
+ self.TOTAL: int(fields[1]),
+ self.USED: int(fields[2]),
+ self.AVAIL: int(fields[3]),
+ # Strip the percentage symbol
+ self.PERCENT_USED: int(fields[4][:-1])
+ }
+ return (response)
diff --git a/tools/lab/metrics/metric.py b/tools/lab/metrics/metric.py
new file mode 100644
index 0000000..9f54237
--- /dev/null
+++ b/tools/lab/metrics/metric.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+#
+# 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.
+
+from utils import job
+from utils import shell
+
+
+class Metric(object):
+ """Interface class for metric gathering.
+
+ Attributes:
+ _shell: a shell.ShellCommand object
+ """
+
+ def __init__(self, shell=shell.ShellCommand(job)):
+ self._shell = shell
+
+ def gather_metric(self):
+ """Gathers all values that this metric watches.
+
+ Mandatory for every class that extends Metric. Should always return.
+
+ Returns:
+ A dict mapping keys (class level constant strings representing
+ fields of a metric) to their statistics.
+
+ Raises:
+ NotImplementedError: A metric did not implement this function.
+ """
+ raise NotImplementedError()
diff --git a/tools/lab/metrics/usb_metric.py b/tools/lab/metrics/usb_metric.py
new file mode 100644
index 0000000..2bead7a
--- /dev/null
+++ b/tools/lab/metrics/usb_metric.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+#
+# 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.
+
+from metrics.metric import Metric
+import job
+
+
+class UsbMetric(Metric):
+ def check_usbmon(self):
+ try:
+ job.run('grep usbmon /proc/modules')
+ except job.Error:
+ print('Kernel module not loaded, attempting to load usbmon')
+ result = job.run('modprobe usbmon', ignore_status=True)
+ if result.exit_status != 0:
+ print result.stderr
+
+ def gather_metric(self):
+ self.check_usbmon()
diff --git a/tools/lab/reporter.py b/tools/lab/reporter.py
new file mode 100644
index 0000000..ce11412
--- /dev/null
+++ b/tools/lab/reporter.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+#
+# 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.
+
+
+class Reporter(object):
+ """ Base class for the multiple ways to report the data gathered.
+
+ The method report takes in a dictionary where the key is the class that
+ generated the value, and the value is the actual data gathered from
+ collecting that metric. For example, an UptimeMetric, would have
+ UptimeMetric() as key, and '1-02:22:42' as the value.
+ """
+
+ def report(self, responses):
+ raise NotImplementedError('Must implement this method')
+
+
+class LoggerReporter(Reporter):
+ def report(self, response_dict):
+ for key in response_dict:
+ print(response_dict[key])
+
+
+class FileReporter(Reporter):
+ pass
diff --git a/tools/lab/runner.py b/tools/lab/runner.py
new file mode 100644
index 0000000..7506938
--- /dev/null
+++ b/tools/lab/runner.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+#
+# 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.
+
+
+class Runner:
+ """Calls metrics and passes response to reporters.
+
+ Attributes:
+ metric_list: a list of metric objects
+ reporter_list: a list of reporter objects
+ object and value is dictionary returned by that response
+ """
+
+ def __init__(self, metric_list, reporter_list):
+ self.metric_list = metric_list
+ self.reporter_list = reporter_list
+
+ def run(self):
+ """Calls metrics and passes response to reporters."""
+ raise NotImplementedError()
+
+
+class InstantRunner(Runner):
+ def run(self):
+ """Calls all metrics, passes responses to reporters."""
+ responses = {}
+ for metric in self.metric_list:
+ responses[metric] = metric.gatherMetric()
+ for reporter in self.reporter_list:
+ reporter.report(responses)
diff --git a/tools/lab/test_main.py b/tools/lab/test_main.py
new file mode 100755
index 0000000..48dc714
--- /dev/null
+++ b/tools/lab/test_main.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+#
+# 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 unittest
+
+if __name__ == "__main__":
+ suite = unittest.TestLoader().discover('.', pattern="*_test.py")
+ unittest.TextTestRunner().run(suite)
diff --git a/tools/lab/tests/__init__.py b/tools/lab/tests/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/lab/tests/__init__.py
diff --git a/tools/lab/tests/disk_metric_test.py b/tools/lab/tests/disk_metric_test.py
new file mode 100755
index 0000000..339ed49
--- /dev/null
+++ b/tools/lab/tests/disk_metric_test.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+#
+# 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 unittest
+
+from metrics import disk_metric
+from tests import fake
+
+
+class DiskMetricTest(unittest.TestCase):
+ """Class for testing DiskMetric."""
+
+ def setUp(self):
+ pass
+
+ def test_return_total_used_avail_percent(self):
+ # Create sample stdout string ShellCommand.run() would return
+ stdout_string = ('Filesystem 1K-blocks Used Available Use% '
+ 'mounted on\n/dev/dm-1 57542652 18358676 '
+ '36237928 34% /')
+ self.FAKE_RESULT = fake.FakeResult(stdout=stdout_string)
+ fake_shell = fake.MockShellCommand(fake_result=self.FAKE_RESULT)
+ self.metric_obj = disk_metric.DiskMetric(shell=fake_shell)
+
+ expected_result = {
+ disk_metric.DiskMetric.TOTAL: 57542652,
+ disk_metric.DiskMetric.USED: 18358676,
+ disk_metric.DiskMetric.AVAIL: 36237928,
+ disk_metric.DiskMetric.PERCENT_USED: 34
+ }
+ self.assertEqual(expected_result, self.metric_obj.gather_metric())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tools/lab/tests/fake.py b/tools/lab/tests/fake.py
new file mode 100644
index 0000000..628a725
--- /dev/null
+++ b/tools/lab/tests/fake.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+#
+# 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.
+
+
+class FakeResult(object):
+ """A fake version of the object returned from ShellCommand.run. """
+
+ def __init__(self, exit_status=1, stdout='', stderr=''):
+ self.exit_status = exit_status
+ self.stdout = stdout
+ self.stderr = stderr
+
+
+class MockShellCommand(object):
+ """A fake ShellCommand object.
+
+ Attributes:
+ fake_result: a FakeResult object
+ """
+
+ def __init__(self, fake_result):
+ self._fake_result = fake_result
+
+ """Returns a FakeResult object.
+
+ Args:
+ Same as ShellCommand.run, but none are used in function
+
+ Returns:
+ The FakeResult object it was initalized with
+ """
+
+ def run(self, command, timeout=3600):
+ return self._fake_result
diff --git a/tools/lab/utils/__init__.py b/tools/lab/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/lab/utils/__init__.py
diff --git a/tools/lab/utils/job.py b/tools/lab/utils/job.py
new file mode 100644
index 0000000..da565c7
--- /dev/null
+++ b/tools/lab/utils/job.py
@@ -0,0 +1,201 @@
+# 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 logging
+import os
+import shlex
+import sys
+import time
+
+if os.name == 'posix' and sys.version_info[0] < 3:
+ import subprocess32 as subprocess
+ DEVNULL = open(os.devnull, 'wb')
+else:
+ import subprocess
+ # Only exists in python3.3
+ from subprocess import DEVNULL
+
+
+class Error(Exception):
+ """Indicates that a command failed, is fatal to the test unless caught."""
+
+ def __init__(self, result):
+ super(Error, self).__init__(result)
+ self.result = result
+
+
+class TimeoutError(Error):
+ """Thrown when a BackgroundJob times out on wait."""
+
+
+class Result(object):
+ """Command execution result.
+
+ Contains information on subprocess execution after it has exited.
+
+ Attributes:
+ command: An array containing the command and all arguments that
+ was executed.
+ exit_status: Integer exit code of the process.
+ stdout_raw: The raw bytes output from standard out.
+ stderr_raw: The raw bytes output from standard error
+ duration: How long the process ran for.
+ did_timeout: True if the program timed out and was killed.
+ """
+
+ @property
+ def stdout(self):
+ """String representation of standard output."""
+ if not self._stdout_str:
+ self._stdout_str = self._raw_stdout.decode(encoding=self._encoding)
+ self._stdout_str = self._stdout_str.strip()
+ return self._stdout_str
+
+ @property
+ def stderr(self):
+ """String representation of standard error."""
+ if not self._stderr_str:
+ self._stderr_str = self._raw_stderr.decode(encoding=self._encoding)
+ self._stderr_str = self._stderr_str.strip()
+ return self._stderr_str
+
+ def __init__(self,
+ command=[],
+ stdout=bytes(),
+ stderr=bytes(),
+ exit_status=None,
+ duration=0,
+ did_timeout=False,
+ encoding='utf-8'):
+ """
+ Args:
+ command: The command that was run. This will be a list containing
+ the executed command and all args.
+ stdout: The raw bytes that standard output gave.
+ stderr: The raw bytes that standard error gave.
+ exit_status: The exit status of the command.
+ duration: How long the command ran.
+ did_timeout: True if the command timed out.
+ encoding: The encoding standard that the program uses.
+ """
+ self.command = command
+ self.exit_status = exit_status
+ self._raw_stdout = stdout
+ self._raw_stderr = stderr
+ self._stdout_str = None
+ self._stderr_str = None
+ self._encoding = encoding
+ self.duration = duration
+ self.did_timeout = did_timeout
+
+ def __repr__(self):
+ return ('job.Result(command=%r, stdout=%r, stderr=%r, exit_status=%r, '
+ 'duration=%r, did_timeout=%r, encoding=%r)') % (
+ self.command, self._raw_stdout, self._raw_stderr,
+ self.exit_status, self.duration, self.did_timeout,
+ self._encoding)
+
+
+def run(command,
+ timeout=60,
+ ignore_status=False,
+ env=None,
+ io_encoding='utf-8'):
+ """Execute a command in a subproccess and return its output.
+
+ Commands can be either shell commands (given as strings) or the
+ path and arguments to an executable (given as a list). This function
+ will block until the subprocess finishes or times out.
+
+ Args:
+ command: The command to execute. Can be either a string or a list.
+ timeout: number seconds to wait for command to finish.
+ ignore_status: bool True to ignore the exit code of the remote
+ subprocess. Note that if you do ignore status codes,
+ you should handle non-zero exit codes explicitly.
+ env: dict enviroment variables to setup on the remote host.
+ io_encoding: str unicode encoding of command output.
+
+ Returns:
+ A job.Result containing the results of the ssh command.
+
+ Raises:
+ job.TimeoutError: When the remote command took to long to execute.
+ Error: When the ssh connection failed to be created.
+ CommandError: Ssh worked, but the command had an error executing.
+ """
+ start_time = time.time()
+ proc = subprocess.Popen(
+ command,
+ env=env,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ shell=not isinstance(command, list))
+ # Wait on the process terminating
+ timed_out = False
+ out = bytes()
+ err = bytes()
+ try:
+ (out, err) = proc.communicate(timeout=timeout)
+ except subprocess.TimeoutExpired:
+ timed_out = True
+ proc.kill()
+ proc.wait()
+
+ result = Result(
+ command=command,
+ stdout=out,
+ stderr=err,
+ exit_status=proc.returncode,
+ duration=time.time() - start_time,
+ encoding=io_encoding,
+ did_timeout=timed_out)
+ logging.debug(result)
+
+ if timed_out:
+ logging.error("Command %s with %s timeout setting timed out", command,
+ timeout)
+ raise TimeoutError(result)
+
+ if not ignore_status and proc.returncode != 0:
+ raise Error(result)
+
+ return result
+
+
+def run_async(command, env=None):
+ """Execute a command in a subproccess asynchronously.
+
+ It is the callers responsibility to kill/wait on the resulting
+ subprocess.Popen object.
+
+ Commands can be either shell commands (given as strings) or the
+ path and arguments to an executable (given as a list). This function
+ will not block.
+
+ Args:
+ command: The command to execute. Can be either a string or a list.
+ env: dict enviroment variables to setup on the remote host.
+
+ Returns:
+ A subprocess.Popen object representing the created subprocess.
+
+ """
+ return subprocess.Popen(
+ command,
+ env=env,
+ close_fds=True,
+ shell=not isinstance(command, list),
+ stdout=DEVNULL,
+ stderr=subprocess.STDOUT)
diff --git a/tools/lab/utils/shell.py b/tools/lab/utils/shell.py
new file mode 100644
index 0000000..5655dd4
--- /dev/null
+++ b/tools/lab/utils/shell.py
@@ -0,0 +1,238 @@
+# 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 shellescape
+import signal
+import time
+
+from utils import job
+
+
+class ShellCommand(object):
+ """Wraps basic commands that tend to be tied very closely to a shell.
+
+ This class is a wrapper for running basic shell commands through
+ any object that has a run command. Basic shell functionality for managing
+ the system, programs, and files in wrapped within this class.
+
+ Note: At the moment this only works with the ssh runner.
+ """
+
+ def __init__(self, runner, working_dir=None):
+ """Creates a new shell command invoker.
+
+ Args:
+ runner: The object that will run the shell commands.
+ working_dir: The directory that all commands should work in,
+ if none then the runners enviroment default is used.
+ """
+ self._runner = runner
+ self._working_dir = working_dir
+
+ def run(self, command, timeout=3600):
+ """Runs a generic command through the runner.
+
+ Takes the command and prepares it to be run in the target shell using
+ this objects settings.
+
+ Args:
+ command: The command to run.
+ timeout: How long to wait for the command (in seconds).
+
+ Returns:
+ A CmdResult object containing the results of the shell command.
+
+ Raises:
+ job.Error: When the command executed but had an error.
+ """
+ if self._working_dir:
+ command_str = 'cd %s; %s' % (self._working_dir, command)
+ else:
+ command_str = command
+
+ return self._runner.run(command_str, timeout=timeout)
+
+ def is_alive(self, identifier):
+ """Checks to see if a program is alive.
+
+ Checks to see if a program is alive on the shells enviroment. This can
+ be used to check on generic programs, or a specific program using
+ a pid.
+
+ Args:
+ identifier: string or int, Used to identify the program to check.
+ if given an int then it is assumed to be a pid. If
+ given a string then it will be used as a search key
+ to compare on the running processes.
+ Returns:
+ True if a process was found running, false otherwise.
+ """
+ try:
+ if isinstance(identifier, str):
+ self.run('ps aux | grep -v grep | grep %s' % identifier)
+ elif isinstance(identifier, int):
+ self.signal(identifier, 0)
+ else:
+ raise ValueError('Bad type was given for identifier')
+
+ return True
+ except job.Error:
+ return False
+
+ def get_pids(self, identifier):
+ """Gets the pids of a program.
+
+ Searches for a program with a specific name and grabs the pids for all
+ programs that match.
+
+ Args:
+ identifier: A search term that identifies the program.
+
+ Returns: An array of all pids that matched the identifier, or None
+ if no pids were found.
+ """
+ try:
+ result = self.run('ps aux | grep -v grep | grep %s' % identifier)
+ except job.Error:
+ raise StopIteration
+
+ lines = result.stdout.splitlines()
+
+ # The expected output of the above command is like so:
+ # bob 14349 0.0 0.0 34788 5552 pts/2 Ss Oct10 0:03 bash
+ # bob 52967 0.0 0.0 34972 5152 pts/4 Ss Oct10 0:00 bash
+ # Where the format is:
+ # USER PID ...
+ for line in lines:
+ pieces = line.split()
+ yield int(pieces[1])
+
+ def search_file(self, search_string, file_name):
+ """Searches through a file for a string.
+
+ Args:
+ search_string: The string or pattern to look for.
+ file_name: The name of the file to search.
+
+ Returns:
+ True if the string or pattern was found, False otherwise.
+ """
+ try:
+ self.run('grep %s %s' % (shellescape.quote(search_string),
+ file_name))
+ return True
+ except job.Error:
+ return False
+
+ def read_file(self, file_name):
+ """Reads a file through the shell.
+
+ Args:
+ file_name: The name of the file to read.
+
+ Returns:
+ A string of the files contents.
+ """
+ return self.run('cat %s' % file_name).stdout
+
+ def write_file(self, file_name, data):
+ """Writes a block of data to a file through the shell.
+
+ Args:
+ file_name: The name of the file to write to.
+ data: The string of data to write.
+ """
+ return self.run('echo %s > %s' % (shellescape.quote(data), file_name))
+
+ def append_file(self, file_name, data):
+ """Appends a block of data to a file through the shell.
+
+ Args:
+ file_name: The name of the file to write to.
+ data: The string of data to write.
+ """
+ return self.run('echo %s >> %s' % (shellescape.quote(data), file_name))
+
+ def touch_file(self, file_name):
+ """Creates a file through the shell.
+
+ Args:
+ file_name: The name of the file to create.
+ """
+ self.write_file(file_name, '')
+
+ def delete_file(self, file_name):
+ """Deletes a file through the shell.
+
+ Args:
+ file_name: The name of the file to delete.
+ """
+ try:
+ self.run('rm %s' % file_name)
+ except job.Error as e:
+ if 'No such file or directory' in e.result.stderr:
+ return
+
+ raise
+
+ def kill(self, identifier, timeout=10):
+ """Kills a program or group of programs through the shell.
+
+ Kills all programs that match an identifier through the shell. This
+ will send an increasing queue of kill signals to all programs
+ that match the identifier until either all are dead or the timeout
+ finishes.
+
+ Programs are guranteed to be killed after running this command.
+
+ Args:
+ identifier: A string used to identify the program.
+ timeout: The time to wait for all programs to die. Each signal will
+ take an equal portion of this time.
+ """
+ if isinstance(identifier, int):
+ pids = [identifier]
+ else:
+ pids = list(self.get_pids(identifier))
+
+ signal_queue = [signal.SIGINT, signal.SIGTERM, signal.SIGKILL]
+
+ signal_duration = timeout / len(signal_queue)
+ for sig in signal_queue:
+ for pid in pids:
+ try:
+ self.signal(pid, sig)
+ except job.Error:
+ pass
+
+ start_time = time.time()
+ while pids and time.time() - start_time < signal_duration:
+ time.sleep(0.1)
+ pids = [pid for pid in pids if self.is_alive(pid)]
+
+ if not pids:
+ break
+
+ def signal(self, pid, sig):
+ """Sends a specific signal to a program.
+
+ Args:
+ pid: The process id of the program to kill.
+ sig: The singal to send.
+
+ Raises:
+ job.Error: Raised when the signal fail to reach
+ the specified program.
+ """
+ self.run('kill -%d %d' % (sig, pid))