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 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 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_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)
