def wait_le_set_cig_parameters_complete(self):
set_cig_params_complete_capture = PyLeIso.IsoCigComplete(
iso_facade_pb2.IsoMsgType.ISO_PARAMETERS_SET_COMPLETE)
assertThat(self._iso_event_stream).emits(
set_cig_params_complete_capture, timeout=timedelta(seconds=5))
return set_cig_params_complete_capture.get()
def _set_name(self):
padded_name = self.cert_name
while len(padded_name) < 248:
padded_name = padded_name + b'\0'
self.cert_hci.send_command(hci_packets.WriteLocalNameBuilder(padded_name))
assertThat(self.cert_hci.get_event_stream()).emits(HciMatchers.CommandComplete(OpCode.WRITE_LOCAL_NAME))
def wait_for_disconnect_event(self):
"""
The Address is expected to be returned
"""
logging.info("DUT: Waiting for Disconnect Event")
assertThat(self._disconnect_event_stream).emits(
lambda event: logging.info("event: %s" % event.address) or True)
def on_user_input(self,
cert_address,
reply_boolean,
expected_ui_event,
pin=[]):
"""
Respond to the UI event
"""
if expected_ui_event is None:
return
ui_id = -1
def get_unique_id(event):
if event.message_type == expected_ui_event:
nonlocal ui_id
ui_id = event.unique_id
return True
return False
logging.info("DUT: Waiting for expected UI event")
assertThat(self._ui_event_stream).emits(get_unique_id)
callback_type = UiCallbackType.YES_NO if len(
pin) == 0 else UiCallbackType.PIN
self.__send_ui_callback(cert_address, callback_type, reply_boolean,
ui_id, pin)
def wait_le_cis_established(self):
cis_establshed_capture = PyLeIso.IsoCigEstablished(
iso_facade_pb2.IsoMsgType.ISO_CIS_ESTABLISHED)
assertThat(self._iso_event_stream).emits(cis_establshed_capture,
timeout=timedelta(seconds=5))
cis_handle = cis_establshed_capture.get()[0]
return PyLeIsoStream(self._device, cis_handle, self._iso_data_stream)
def wait_for_disconnect_event(self):
"""
Cert side needs to pass
"""
logging.info("Cert: Waiting for DISCONNECT_COMPLETE")
assertThat(self._hci_event_stream).emits(
HciMatchers.DisconnectionComplete())
def test_just_works_iut_responder_secure_connections(self):
"""
Verify that the IUT supporting LE Secure Connections is able to perform the Just Works or Numeric Comparison pairing procedure correctly when acting as responder.
"""
self._prepare_dut_for_connection()
self.dut.security.SetLeIoCapability(KEYBOARD_ONLY)
self.dut.security.SetLeOobDataPresent(OOB_NOT_PRESENT)
self.dut_security.SetLeAuthRequirements(secure_connections=1)
self.cert.security.SetLeIoCapability(NO_INPUT_NO_OUTPUT)
self.cert.security.SetLeOobDataPresent(OOB_NOT_PRESENT)
self.cert_security.SetLeAuthRequirements(secure_connections=1)
# 1. Lower Tester transmits Pairing Request command with:
# a. IO capability set to “NoInputNoOutput”
# b. OOB data flag set to 0x00 (OOB Authentication data not present)
# c. AuthReq Bonding Flags set to ‘00’, MITM flag set to ‘0’, Secure Connections flag set to '1' and all reserved bits are set to ‘0’
self.cert.security.CreateBondLe(self.dut_address)
assertThat(self.dut_security.get_ui_stream()).emits(
SecurityMatchers.UiMsg(UiMsgType.DISPLAY_PAIRING_PROMPT))
# 2. IUT responds with a Pairing Response command, with:
# a. IO capability set to any IO capability
# b. AuthReq Bonding Flags set to ‘00’, MITM flag set to either ‘0’ for Just Works or '1' for Numeric Comparison, Secure Connections flag set to '1' and all reserved bits are set to ‘0’
self.dut.security.SendUiCallback(
UiCallbackMsg(message_type=UiCallbackType.PAIRING_PROMPT,
boolean=True,
unique_id=1,
address=self.cert_address))
# 3. UT and Lower Tester perform phase 2 of the Just Works or Numeric Comparison pairing procedure according to the MITM flag and IO capabilities, and establish an encrypted link with the LTK generated in phase 2.
assertThat(self.dut_security.get_bond_stream()).emits(
SecurityMatchers.BondMsg(BondMsgType.DEVICE_BONDED))
def test_receive_i_frame_final_bit_set(self):
"""
L2CAP/ERM/BV-19-C [Receive I-Frame Final Bit = 1]
Verify the IUT will retransmit any previously sent I-frames unacknowledged by receipt of an I-frame
with the final bit set.
"""
self._setup_link_from_cert()
self.cert_l2cap.turn_on_ertm()
(dut_channel, cert_channel) = self._open_channel(scid=0x41,
psm=0x33,
use_ertm=True)
dut_channel.send(b'abc')
# TODO: Always use their retransmission timeout value
time.sleep(2)
assertThat(cert_channel).emits(L2capMatchers.SFrame(p=Poll.POLL))
cert_channel.send_i_frame(tx_seq=0,
req_seq=0,
f=Final.POLL_RESPONSE,
payload=SAMPLE_PACKET)
assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))
def test_fixed_channel_receive(self):
self.dut_l2cap.enable_fixed_channel(4)
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_fixed_channel(4)
cert_channel.send(SAMPLE_PACKET)
assertThat(dut_channel).emits(
L2capMatchers.PacketPayloadRawData(b'\x19\x26\x08\x17'))
def test_data_receiving_dut_is_central(self):
"""
L2CAP/COS/CFC/BV-04-C
"""
(dut_channel, cert_channel) = self._set_link_from_dut_and_open_channel()
cert_channel.send_first_le_i_frame(4, SAMPLE_PACKET)
assertThat(dut_channel).emits(L2capMatchers.PacketPayloadRawData(b'\x19\x26\x08\x17'))
def test_command_reject_reserved_pdu_codes(self):
"""
Verify that an IUT receiving a PDU with a reserved command code sends a command reject.
"""
self._setup_link_from_cert()
self.cert_l2cap.get_control_channel().send(l2cap_packets.MoveChannelRequestBuilder(2, 0, 0))
assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.LeCommandReject())
def test_no_segmentation_dut_is_central(self):
"""
L2CAP/COS/CFC/BV-02-C
"""
(dut_channel, cert_channel) = self._set_link_from_dut_and_open_channel()
dut_channel.send(b'hello' * 40)
assertThat(cert_channel).emits(L2capMatchers.FirstLeIFrame(b'hello' * 40, sdu_size=200))
def test_connect_dynamic_channel_and_send_data(self):
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_channel(scid=0x41, psm=0x33)
dut_channel.send(b'abc')
assertThat(cert_channel).emits(L2capMatchers.Data(b'abc'))
def test_filtering_event_stream_none_filter_function(self):
with EventStream(FetchEvents(events=[1, 2, 3],
delay_ms=50)) as event_stream:
filtered_event_stream = FilteringEventStream(event_stream, None)
assertThat(filtered_event_stream)\
.emits(lambda data: data.value_ == 1)\
.then(lambda data: data.value_ == 3)
def test_assertThat_emitsNone_passes_core():
with EventStream(FetchEvents(events=[1, 2, 3],
delay_ms=50)) as event_stream:
assertThat(event_stream).emitsNone(
lambda data: data.value_ == 4,
timeout=timedelta(seconds=0.15)).thenNone(
lambda data: data.value_ == 5, timeout=timedelta(seconds=0.15))
def test_assertThat_eventStream_emitsInAnyOrder_passes(self):
with EventStream(FetchEvents(events=[1, 2, 3],
delay_ms=50)) as event_stream:
assertThat(event_stream).emits(
lambda data: data.value_ == 2,
lambda data: data.value_ == 1).inAnyOrder().then(
lambda data: data.value_ == 3)
def test_data_receiving(self):
"""
Verify that the IUT can receive unsegmented data correctly.
"""
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_channel_from_cert()
cert_channel.send_first_le_i_frame(4, SAMPLE_PACKET)
assertThat(dut_channel).emits(L2capMatchers.PacketPayloadRawData(b'\x19\x26\x08\x17'))
def test_no_segmentation(self):
"""
Verify that the IUT can send data segments which do not require segmentation.
"""
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_channel_from_cert(mtu=1000, mps=202)
dut_channel.send(b'hello' * 40)
assertThat(cert_channel).emits(L2capMatchers.FirstLeIFrame(b'hello' * 40, sdu_size=200))
def send_configure_request(self,
options,
sid=2,
continuation=l2cap_packets.Continuation.END):
assertThat(self._scid).isNotEqualTo(1)
request = l2cap_packets.ConfigurationRequestBuilder(
sid, self._dcid, continuation, options)
self._control_channel.send(request)
def test_credit_based_connection_response_on_supported_le_psm(self):
"""
Verify that an IUT receiving a valid LE Credit Based Connection Request from a peer will send an LE Credit Based Connection Response and establish the channel.
"""
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_channel_from_cert()
dut_channel.send(b'hello')
assertThat(cert_channel).emits(L2capMatchers.FirstLeIFrame(b'hello', sdu_size=5))
def initiate_connection(self, remote_addr):
assertThat(self.next_token in
self.outgoing_connection_event_streams).isFalse()
self.outgoing_connection_event_streams[self.next_token] = EventStream(
self.le_acl_manager.CreateConnection(remote_addr)), remote_addr
token = self.next_token
self.next_token += 1
return token
def disconnect_and_verify(self):
assertThat(self._scid).isNotEqualTo(1)
self._control_channel.send(
l2cap_packets.LeDisconnectionRequestBuilder(
1, self._dcid, self._scid))
assertThat(self._control_channel).emits(
L2capMatchers.LeDisconnectionResponse(self._scid, self._dcid))
def test_le_credit_based_connection_request_legacy_peer(self):
"""
Verify that an IUT sending an LE Credit Based Connection Request to a legacy peer and receiving a Command Reject does not establish the channel.
"""
self._setup_link_from_cert()
response_future = self.dut_l2cap.connect_coc_to_cert(self.cert_address, psm=0x33)
self.cert_l2cap.verify_and_reject_open_channel_from_remote(psm=0x33)
assertThat(response_future.get_status()).isNotEqualTo(LeCreditBasedConnectionResponseResult.SUCCESS)
def initiate_connection(self, remote_addr):
assertThat(self.outgoing_connection_event_stream).isNone()
remote_addr_bytes = bytes(
remote_addr,
'utf8') if type(remote_addr) is str else bytes(remote_addr)
self.outgoing_connection_event_stream = EventStream(
self.acl_manager.CreateConnection(
acl_manager_facade.ConnectionMsg(address=remote_addr_bytes)))
def test_le_credit_based_connection_request_on_supported_le_psm(self):
"""
Verify that an IUT sending an LE Credit Based Connection Request to a peer will establish the channel upon receiving the LE Credit Based Connection Response.
"""
self._setup_link_from_cert()
(dut_channel, cert_channel) = self._open_channel_from_dut()
cert_channel.send_first_le_i_frame(4, SAMPLE_PACKET)
assertThat(dut_channel).emits(L2capMatchers.PacketPayloadRawData(b'\x19\x26\x08\x17'))
def complete_connection(self):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(self.event_stream).emits(connection_complete)
handle = connection_complete.get().GetConnectionHandle()
if self.acl_stream is None:
raise Exception("Please construct '%s' with acl_streaming=True!" % self.__class__.__name__)
return PyHciAclConnection(handle, self.acl_stream, self.device)
def test_reject_connection_parameter_update_request(self):
"""
Verify that the IUT is able to reject a request for connection parameter update in peripheral mode.
"""
self._setup_link_from_cert()
self.cert_l2cap.get_control_channel().send(
l2cap_packets.ConnectionParameterUpdateRequestBuilder(2, 0x10, 0x10, 0x0a, 0x64))
assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.LeCommandReject())
def start(self):
enabled_set = EnabledSet()
enabled_set.advertising_handle = self.handle
enabled_set.duration = 0
enabled_set.max_extended_advertising_events = 0
self.py_hci.send_command(LeSetExtendedAdvertisingEnableBuilder(Enable.ENABLED, [enabled_set]))
assertThat(self.py_hci.get_event_stream()).emits(
HciMatchers.CommandComplete(OpCode.LE_SET_EXTENDED_ADVERTISING_ENABLE))
def complete_connection(self, event_stream):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(event_stream).emits(connection_complete)
complete = connection_complete.get()
handle = complete.GetConnectionHandle()
address = complete.GetBdAddr()
return PyAclManagerAclConnection(self.acl_manager, address, handle,
event_stream)
def accept_connection(self):
connection_request = HciCaptures.ConnectionRequestCapture()
assertThat(self.event_stream).emits(connection_request)
self.send_command(
hci_packets.AcceptConnectionRequestBuilder(connection_request.get().GetBdAddr(),
hci_packets.AcceptConnectionRequestRole.REMAIN_PERIPHERAL))
return self.complete_connection()
