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)