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 120 seconds
autils.configure_mac_random_interval(dut, 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)
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 setup_test(self):
required_params = ("aware_default_power_mode", )
self.unpack_userparams(required_params)
for ad in self.android_devices:
asserts.skip_if(
not ad.droid.doesDeviceSupportWifiAwareFeature(),
"Device under test does not support Wi-Fi Aware - skipping test"
)
wutils.wifi_toggle_state(ad, True)
ad.droid.wifiP2pClose()
utils.set_location_service(ad, True)
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.clear_all_events()
ad.aware_capabilities = autils.get_aware_capabilities(ad)
self.reset_device_parameters(ad)
self.reset_device_statistics(ad)
self.set_power_mode_parameters(ad)
wutils.set_wifi_country_code(ad, wutils.WifiEnums.CountryCode.US)
autils.configure_ndp_allow_any_override(ad, True)
# set randomization interval to 0 (disable) to reduce likelihood of
# interference in tests
autils.configure_mac_random_interval(ad, 0)
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_rtt_oob_discovery_set(self, do_both_directions, iter_count,
time_between_iterations, time_between_roles):
"""Perform a set of RTT measurements, using out-of-band discovery.
Args:
do_both_directions: False - perform all measurements in one direction,
True - perform 2 measurements one in both directions.
iter_count: Number of measurements to perform.
time_between_iterations: Number of seconds to wait between iterations.
time_between_roles: Number of seconds to wait when switching between
Initiator and Responder roles (only matters if
do_both_directions=True).
enable_ranging: True to enable Ranging, False to disable.
Returns: a list of the events containing the RTT results (or None for a
failed measurement). If both directions are tested then returns a list of
2 elements: one set for each direction.
"""
dut0 = self.android_devices[0]
dut1 = self.android_devices[1]
id0, mac0 = autils.attach_with_identity(dut0)
id1, mac1 = autils.attach_with_identity(dut1)
# 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)
# start publisher(s) on the Responder(s) with ranging enabled
p_config = autils.add_ranging_to_pub(autils.create_discovery_config(
self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED),
enable_ranging=True)
dut1.droid.wifiAwarePublish(id1, p_config)
autils.wait_for_event(dut1, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
if do_both_directions:
dut0.droid.wifiAwarePublish(id0, p_config)
autils.wait_for_event(dut0, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
results01 = []
results10 = []
for i in range(iter_count):
if i != 0 and time_between_iterations != 0:
time.sleep(time_between_iterations)
# perform RTT from dut0 -> dut1
results01.append(self.run_rtt_discovery(dut0, resp_mac=mac1))
if do_both_directions:
if time_between_roles != 0:
time.sleep(time_between_roles)
# perform RTT from dut1 -> dut0
results10.append(self.run_rtt_discovery(dut1, resp_mac=mac0))
return results01 if not do_both_directions else [results01, results10]
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 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 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_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]
# re-enable randomization interval (since if disabled it may also disable
# the 'randomize on enable' feature).
autils.configure_mac_random_interval(dut, 1800)
# 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 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 setup_test(self):
required_params = ("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 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 start_aware(self, dut, is_publish):
"""Start Aware attach, then start Publish/Subscribe based on role
Args:
dut: Aware device
is_publish: True for Publisher, False for subscriber
@:return: dict with Aware discovery session info
"""
aware_id = dut.droid.wifiAwareAttach(True)
autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
event = autils.wait_for_event(dut, aconsts.EVENT_CB_ON_IDENTITY_CHANGED)
mac = self.transfer_mac_format(event["data"]["mac"])
dut.log.info("NMI=%s", mac)
if is_publish:
config = autils.create_discovery_config(self.SERVICE_NAME,
aconsts.PUBLISH_TYPE_UNSOLICITED)
disc_id = dut.droid.wifiAwarePublish(aware_id, config)
autils.wait_for_event(dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
else:
config = autils.create_discovery_config(self.SERVICE_NAME,
aconsts.SUBSCRIBE_TYPE_PASSIVE)
disc_id = dut.droid.wifiAwareSubscribe(aware_id, config)
autils.wait_for_event(dut, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
aware_session = {"awareId": aware_id, "discId": disc_id, "mac": mac}
return aware_session
def test_rtt_without_initiator_aware(self):
"""Try to perform RTT operation when there is no local Aware session (on the
Initiator). The Responder is configured normally: Aware on and a Publisher
with Ranging enable. Should FAIL.
"""
init_dut = self.android_devices[0]
resp_dut = self.android_devices[1]
# Enable a Responder and start a Publisher
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']
resp_config = autils.add_ranging_to_pub(autils.create_discovery_config(
self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED),
enable_ranging=True)
resp_dut.droid.wifiAwarePublish(resp_id, resp_config)
autils.wait_for_event(resp_dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
# Initiate an RTT to Responder (no Aware started on Initiator!)
results = []
num_no_responses = 0
num_successes = 0
for i in range(self.NUM_ITER):
result = self.run_rtt_discovery(init_dut, resp_mac=resp_mac)
self.log.debug("result: %s", result)
results.append(result)
if result is None:
num_no_responses = num_no_responses + 1
elif (result[rconsts.EVENT_CB_RANGING_KEY_STATUS] ==
rconsts.EVENT_CB_RANGING_STATUS_SUCCESS):
num_successes = num_successes + 1
asserts.assert_equal(num_no_responses,
0,
"No RTT response?",
extras={"data": results})
asserts.assert_equal(num_successes,
0,
"Aware RTT w/o Aware should FAIL!",
extras={"data": results})
asserts.explicit_pass("RTT Aware test done", extras={"data": results})
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 setup_test(self):
required_params = ("aware_default_power_mode", )
self.unpack_userparams(required_params)
for ad in self.android_devices:
asserts.skip_if(
not ad.droid.doesDeviceSupportWifiAwareFeature(),
"Device under test does not support Wi-Fi Aware - skipping test"
)
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.clear_all_events()
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 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")
def test_infra_assoc_discovery_stress(self):
"""Validates that Wi-Fi Aware discovery does not interfere with
infrastructure (AP) association.
Test assumes (and verifies) that device is already associated to an AP.
"""
dut = self.android_devices[0]
# check that associated and start tracking
dut.droid.wifiStartTrackingStateChange()
asserts.assert_true(self.is_associated(dut),
"DUT is not associated to an AP!")
# attach
session_id = dut.droid.wifiAwareAttach(True)
autils.wait_for_event(dut, aconsts.EVENT_CB_ON_ATTACHED)
# publish
p_disc_id = dut.droid.wifiAwarePublish(
session_id,
autils.create_discovery_config(self.SERVICE_NAME,
aconsts.PUBLISH_TYPE_UNSOLICITED))
autils.wait_for_event(dut, aconsts.SESSION_CB_ON_PUBLISH_STARTED)
# wait for any disassociation change events
any_disassociations = False
try:
dut.ed.pop_event(wconsts.WIFI_DISCONNECTED,
self.TEST_DURATION_SECONDS)
any_disassociations = True
except queue.Empty:
pass
finally:
dut.droid.wifiStopTrackingStateChange()
asserts.assert_false(any_disassociations,
"Wi-Fi disassociated during test run")
def test_attach_with_doze(self):
"""Function test case / Attach test cases / attempt to attach with doze on
Validates that if trying to attach with device in doze mode 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]
asserts.assert_true(utils.enable_doze(dut), "Can't enable doze")
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)
asserts.assert_true(utils.disable_doze(dut), "Can't disable doze")
autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
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)
def test_attach_with_location_off(self):
"""Function test case / Attach test cases / attempt to attach with location
mode off.
Validates that if trying to attach with device location mode off 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]
utils.set_location_service(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)
utils.set_location_service(dut, True)
autils.wait_for_event(dut, aconsts.BROADCAST_WIFI_AWARE_AVAILABLE)
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 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)
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 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 run_multiple_concurrent_services(self, type_x, type_y):
"""Validate multiple identical discovery services running on both devices:
- DUT1 & DUT2 running Publish for X
- DUT1 & DUT2 running Publish for Y
- DUT1 Subscribes for X
- DUT2 Subscribes for Y
Message exchanges.
Note: test requires that devices support 2 publish sessions concurrently.
The test will be skipped if the devices are not capable.
Args:
type_x, type_y: A list of [ptype, stype] of the publish and subscribe
types for services X and Y respectively.
"""
dut1 = self.android_devices[0]
dut2 = self.android_devices[1]
X_SERVICE_NAME = "ServiceXXX"
Y_SERVICE_NAME = "ServiceYYY"
asserts.skip_if(
dut1.aware_capabilities[aconsts.CAP_MAX_PUBLISHES] < 2
or dut2.aware_capabilities[aconsts.CAP_MAX_PUBLISHES] < 2,
"Devices do not support 2 publish sessions")
# attach and wait for confirmation
id1 = dut1.droid.wifiAwareAttach(False)
autils.wait_for_event(dut1, aconsts.EVENT_CB_ON_ATTACHED)
time.sleep(self.device_startup_offset)
id2 = dut2.droid.wifiAwareAttach(False)
autils.wait_for_event(dut2, aconsts.EVENT_CB_ON_ATTACHED)
# DUT1 & DUT2: start publishing both X & Y services and wait for
# confirmations
dut1_x_pid = dut1.droid.wifiAwarePublish(
id1, autils.create_discovery_config(X_SERVICE_NAME, type_x[0]))
event = autils.wait_for_event(dut1,
aconsts.SESSION_CB_ON_PUBLISH_STARTED)
asserts.assert_equal(event["data"][aconsts.SESSION_CB_KEY_SESSION_ID],
dut1_x_pid,
"Unexpected DUT1 X publish session discovery ID")
dut1_y_pid = dut1.droid.wifiAwarePublish(
id1, autils.create_discovery_config(Y_SERVICE_NAME, type_y[0]))
event = autils.wait_for_event(dut1,
aconsts.SESSION_CB_ON_PUBLISH_STARTED)
asserts.assert_equal(event["data"][aconsts.SESSION_CB_KEY_SESSION_ID],
dut1_y_pid,
"Unexpected DUT1 Y publish session discovery ID")
dut2_x_pid = dut2.droid.wifiAwarePublish(
id2, autils.create_discovery_config(X_SERVICE_NAME, type_x[0]))
event = autils.wait_for_event(dut2,
aconsts.SESSION_CB_ON_PUBLISH_STARTED)
asserts.assert_equal(event["data"][aconsts.SESSION_CB_KEY_SESSION_ID],
dut2_x_pid,
"Unexpected DUT2 X publish session discovery ID")
dut2_y_pid = dut2.droid.wifiAwarePublish(
id2, autils.create_discovery_config(Y_SERVICE_NAME, type_y[0]))
event = autils.wait_for_event(dut2,
aconsts.SESSION_CB_ON_PUBLISH_STARTED)
asserts.assert_equal(event["data"][aconsts.SESSION_CB_KEY_SESSION_ID],
dut2_y_pid,
"Unexpected DUT2 Y publish session discovery ID")
# DUT1: start subscribing for X
dut1_x_sid = dut1.droid.wifiAwareSubscribe(
id1, autils.create_discovery_config(X_SERVICE_NAME, type_x[1]))
autils.wait_for_event(dut1, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
# DUT2: start subscribing for Y
dut2_y_sid = dut2.droid.wifiAwareSubscribe(
id2, autils.create_discovery_config(Y_SERVICE_NAME, type_y[1]))
autils.wait_for_event(dut2, aconsts.SESSION_CB_ON_SUBSCRIBE_STARTED)
# DUT1 & DUT2: wait for service discovery
event = autils.wait_for_event(dut1,
aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_SESSION_ID], dut1_x_sid,
"Unexpected DUT1 X subscribe session discovery ID")
dut1_peer_id_for_dut2_x = event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
event = autils.wait_for_event(dut2,
aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_SESSION_ID], dut2_y_sid,
"Unexpected DUT2 Y subscribe session discovery ID")
dut2_peer_id_for_dut1_y = event["data"][aconsts.SESSION_CB_KEY_PEER_ID]
# DUT1.X send message to DUT2
x_msg = "Hello X on DUT2!"
dut1.droid.wifiAwareSendMessage(dut1_x_sid, dut1_peer_id_for_dut2_x,
self.get_next_msg_id(), x_msg,
self.msg_retx_count)
autils.wait_for_event(dut1, aconsts.SESSION_CB_ON_MESSAGE_SENT)
event = autils.wait_for_event(dut2,
aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_SESSION_ID], dut2_x_pid,
"Unexpected publish session ID on DUT2 for meesage "
"received on service X")
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], x_msg,
"Message on service X from DUT1 to DUT2 not received correctly")
# DUT2.Y send message to DUT1
y_msg = "Hello Y on DUT1!"
dut2.droid.wifiAwareSendMessage(dut2_y_sid, dut2_peer_id_for_dut1_y,
self.get_next_msg_id(), y_msg,
self.msg_retx_count)
autils.wait_for_event(dut2, aconsts.SESSION_CB_ON_MESSAGE_SENT)
event = autils.wait_for_event(dut1,
aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_SESSION_ID], dut1_y_pid,
"Unexpected publish session ID on DUT1 for meesage "
"received on service Y")
asserts.assert_equal(
event["data"][aconsts.SESSION_CB_KEY_MESSAGE_AS_STRING], y_msg,
"Message on service Y from DUT2 to DUT1 not received correctly")
def test_ib_multi_data_path_mac_random_test(self):
"""Verify there is no factory MAC Address leakage during the Aware discovery, NDP creation,
socket setup and IP service connection."""
p_dut = self.android_devices[0]
s_dut = self.android_devices[1]
mac_addresses = []
factory_mac_addresses = []
sec_types = [self.ENCR_TYPE_PMK, self.ENCR_TYPE_PASSPHRASE]
self.log.info("Starting packet capture")
pcap_procs = wutils.start_pcap(
self.packet_capture, 'dual', self.test_name)
factory_mac_1 = p_dut.droid.wifigetFactorymacAddresses()[0]
p_dut.log.info("Factory Address: %s", factory_mac_1)
factory_mac_2 = s_dut.droid.wifigetFactorymacAddresses()[0]
s_dut.log.info("Factory Address: %s", factory_mac_2)
factory_mac_addresses.append(factory_mac_1)
factory_mac_addresses.append(factory_mac_2)
# Start Aware and exchange messages
publish_session = self.start_aware(p_dut, True)
subscribe_session = self.start_aware(s_dut, False)
mac_addresses.append(publish_session["mac"])
mac_addresses.append(subscribe_session["mac"])
discovery_event = autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_SERVICE_DISCOVERED)
subscribe_session["peerId"] = discovery_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
msg_id = self.get_next_msg_id()
s_dut.droid.wifiAwareSendMessage(subscribe_session["discId"], subscribe_session["peerId"],
msg_id, self.ping_msg, aconsts.MAX_TX_RETRIES)
autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
pub_rx_msg_event = autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
publish_session["peerId"] = pub_rx_msg_event['data'][aconsts.SESSION_CB_KEY_PEER_ID]
msg_id = self.get_next_msg_id()
p_dut.droid.wifiAwareSendMessage(publish_session["discId"], publish_session["peerId"],
msg_id, self.ping_msg, aconsts.MAX_TX_RETRIES)
autils.wait_for_event(p_dut, aconsts.SESSION_CB_ON_MESSAGE_SENT)
autils.wait_for_event(s_dut, aconsts.SESSION_CB_ON_MESSAGE_RECEIVED)
# Create Aware NDP
p_req_keys = []
s_req_keys = []
for sec in sec_types:
ndp_info = self.create_date_path(p_dut, publish_session, s_dut, subscribe_session, sec)
p_req_keys.append(ndp_info["pubReqKey"])
s_req_keys.append(ndp_info["subReqKey"])
mac_addresses.append(ndp_info["pubIfMac"])
mac_addresses.append(ndp_info["subIfMac"])
# clean-up
for p_req_key in p_req_keys:
p_dut.droid.connectivityUnregisterNetworkCallback(p_req_key)
for s_req_key in s_req_keys:
s_dut.droid.connectivityUnregisterNetworkCallback(s_req_key)
p_dut.droid.wifiAwareDestroyAll()
s_dut.droid.wifiAwareDestroyAll()
self.log.info("Stopping packet capture")
wutils.stop_pcap(self.packet_capture, pcap_procs, False)
self.verify_mac_no_leakage(pcap_procs, factory_mac_addresses, mac_addresses)
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_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)
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 the test will fail.
"""
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]
# get number of attached devices: needs to be max_ndp+2 to allow for max_ndp
# NDPs + an additional one expected to fail.
# However, will run the test with max_ndp+1 devices to verify that at least
# that many NDPs can be created. Will still fail at the end to indicate that
# full test was not run.
num_peer_devices = min(len(self.android_devices) - 1, max_ndp + 1)
asserts.assert_true(
num_peer_devices >= max_ndp,
'A minimum of %d devices is needed to run the test, have %d' %
(max_ndp + 1, 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(num_peer_devices):
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))
asserts.assert_true(
num_peer_devices > max_ndp,
'Needed %d devices to run the test, have %d' %
(max_ndp + 2, len(self.android_devices)))
