def __init__(self, device):
self.device = device
self.hci_event_stream = EventStream(
self.device.hal.StreamEvents(empty_proto.Empty()))
self.acl_stream = EventStream(
self.device.hal.StreamAcl(empty_proto.Empty()))
def setup_test(self):
super().setup_test()
self.dut_le_acl_manager = PyLeAclManager(self.dut)
self.cert_hci_le_event_stream = EventStream(
self.cert.hci.StreamLeSubevents(empty_proto.Empty()))
self.cert_acl_data_stream = EventStream(
self.cert.hci.StreamAcl(empty_proto.Empty()))
def __init__(self, device):
self.device = device
self.hci_event_stream = EventStream(
self.device.hal.FetchHciEvent(empty_proto.Empty()))
self.acl_stream = EventStream(
self.device.hal.FetchHciAcl(empty_proto.Empty()))
def __init__(self, device):
logging.info("DUT: Init")
self._device = device
self._device.wait_channel_ready()
self._iso_event_stream = EventStream(
self._device.iso.FetchIsoEvents(empty_proto.Empty()))
self._iso_data_stream = EventStream(
self._device.iso.FetchIsoData(empty_proto.Empty()))
def __init__(self, device):
logging.info("DUT: Init")
self._device = device
self._device.wait_channel_ready()
self._ui_event_stream = EventStream(
self._device.security.FetchUiEvents(empty_proto.Empty()))
self._bond_event_stream = EventStream(
self._device.security.FetchBondEvents(empty_proto.Empty()))
def __init__(self, acl_manager, remote_addr, handle, event_stream):
self.acl_manager = acl_manager
self.handle = handle
self.remote_addr = remote_addr
self.connection_event_stream = event_stream
self.acl_stream = EventStream(
self.acl_manager.FetchAclData(
acl_manager_facade.HandleMsg(handle=self.handle)))
def __init__(self, device):
logging.debug("DUT: Init")
self._device = device
self._device.wait_channel_ready()
self._ui_event_stream = EventStream(
self._device.security.FetchUiEvents(empty_proto.Empty()))
self._bond_event_stream = EventStream(
self._device.security.FetchBondEvents(empty_proto.Empty()))
self._enforce_security_policy_stream = EventStream(
self._device.security.FetchEnforceSecurityPolicyEvents(
empty_proto.Empty()))
def __init__(self, device, cert_address, has_security=False):
self._device = device
self._cert_address = cert_address
self._hci = PyHci(device)
self._l2cap_stream = EventStream(
self._device.l2cap.FetchL2capData(empty_proto.Empty()))
self._security_connection_event_stream = EventStream(
self._device.l2cap.FetchSecurityConnectionEvents(
empty_proto.Empty()))
if has_security == False:
self._hci.register_for_events(
hci_packets.EventCode.LINK_KEY_REQUEST)
def __init__(self, device, acl_streaming=False):
"""
If you are planning on personally using the ACL data stream
coming from HCI, specify acl_streaming=True. You probably only
want this if you are testing HCI itself.
"""
self.device = device
self.event_stream = EventStream(self.device.hci.StreamEvents(empty_proto.Empty()))
self.le_event_stream = EventStream(self.device.hci.StreamLeSubevents(empty_proto.Empty()))
if acl_streaming:
self.register_for_events(hci_packets.EventCode.ROLE_CHANGE, hci_packets.EventCode.CONNECTION_REQUEST,
hci_packets.EventCode.CONNECTION_COMPLETE,
hci_packets.EventCode.CONNECTION_PACKET_TYPE_CHANGED)
self.acl_stream = EventStream(self.device.hci.StreamAcl(empty_proto.Empty()))
def __init__(self, grpc_port, grpc_root_server_port, cmd, label):
super().__init__(grpc_port, grpc_root_server_port, cmd, label,
ACTS_CONTROLLER_CONFIG_NAME)
# Facade stubs
self.rootservice = facade_rootservice_pb2_grpc.RootFacadeStub(
self.grpc_root_server_channel)
self.hal = hal_facade_pb2_grpc.HciHalFacadeStub(self.grpc_channel)
self.hci = hci_facade_pb2_grpc.AclManagerFacadeStub(self.grpc_channel)
self.hci_classic_security = hci_facade_pb2_grpc.ClassicSecurityManagerFacadeStub(
self.grpc_channel)
self.l2cap = l2cap_facade_pb2_grpc.L2capModuleFacadeStub(
self.grpc_channel)
# Event streams
self.hal.hci_event_stream = EventStream(self.hal.FetchHciEvent)
self.hal.hci_acl_stream = EventStream(self.hal.FetchHciAcl)
self.hal.hci_sco_stream = EventStream(self.hal.FetchHciSco)
self.hci.connection_complete_stream = EventStream(
self.hci.FetchConnectionComplete)
self.hci.disconnection_stream = EventStream(
self.hci.FetchDisconnection)
self.hci.connection_failed_stream = EventStream(
self.hci.FetchConnectionFailed)
self.hci.acl_stream = EventStream(self.hci.FetchAclData)
self.hci_classic_security.command_complete_stream = EventStream(
self.hci_classic_security.FetchCommandCompleteEvent)
def test_remote_name(self):
self.register_for_dut_event(
hci_packets.EventCode.REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION)
with EventStream(self.cert.hci.FetchEvents(empty_proto.Empty())) as hci_event_stream, \
EventStream(self.dut.neighbor.GetRemoteNameEvents(empty_proto.Empty())) as name_event_stream:
cert_name = b'Im_A_Cert'
padded_name = cert_name
while len(padded_name) < 248:
padded_name = padded_name + b'\0'
self.enqueue_hci_command(
hci_packets.WriteLocalNameBuilder(padded_name), True)
hci_event_stream.assert_event_occurs(
lambda msg: b'\x0e\x04\x01\x13\x0c' in msg.event)
address = hci_packets.Address()
def get_address_from_complete(packet):
packet_bytes = packet.event
if b'\x0e\x0a\x01\x09\x10' in packet_bytes:
nonlocal address
addr_view = hci_packets.ReadBdAddrCompleteView(
hci_packets.CommandCompleteView(
hci_packets.EventPacketView(
bt_packets.PacketViewLittleEndian(
list(packet_bytes)))))
address = addr_view.GetBdAddr()
return True
return False
# DUT Enables scans and gets its address
self.enqueue_hci_command(
hci_packets.WriteScanEnableBuilder(
hci_packets.ScanEnable.INQUIRY_AND_PAGE_SCAN), True)
self.enqueue_hci_command(hci_packets.ReadBdAddrBuilder(), True)
hci_event_stream.assert_event_occurs(get_address_from_complete)
cert_address = address.encode('utf8')
self.dut.neighbor.ReadRemoteName(
neighbor_facade.RemoteNameRequestMsg(
address=cert_address,
page_scan_repetition_mode=1,
clock_offset=0x6855))
name_event_stream.assert_event_occurs(
lambda msg: cert_name in msg.name)
def __init__(self, grpc_port, grpc_root_server_port, cmd, label):
super().__init__(grpc_port, grpc_root_server_port, cmd,
label, ACTS_CONTROLLER_CONFIG_NAME)
# Cert stubs
self.rootservice = cert_rootservice_pb2_grpc.RootCertStub(self.grpc_root_server_channel)
self.hal = hal_cert_pb2_grpc.HciHalCertStub(self.grpc_channel)
self.hci = hci_cert_pb2_grpc.AclManagerCertStub(self.grpc_channel)
self.l2cap = l2cap_cert_pb2_grpc.L2capModuleCertStub(self.grpc_channel)
# Event streams
self.hci.connection_complete_stream = EventStream(self.hci.FetchConnectionComplete)
self.hci.disconnection_stream = EventStream(self.hci.FetchDisconnection)
self.hci.connection_failed_stream = EventStream(self.hci.FetchConnectionFailed)
self.hci.acl_stream = EventStream(self.hci.FetchAclData)
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_le_ad_scan_dut_scans(self):
privacy_policy = le_initiator_address_facade.PrivacyPolicy(
address_policy=le_initiator_address_facade.AddressPolicy.
USE_STATIC_ADDRESS,
address_with_type=common.BluetoothAddressWithType(
address=common.BluetoothAddress(
address=bytes(b'D0:05:04:03:02:01')),
type=common.RANDOM_DEVICE_ADDRESS),
rotation_irk=
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
minimum_rotation_time=0,
maximum_rotation_time=0)
self.dut.hci_le_initiator_address.SetPrivacyPolicyForInitiatorAddress(
privacy_policy)
cert_privacy_policy = le_initiator_address_facade.PrivacyPolicy(
address_policy=le_initiator_address_facade.AddressPolicy.
USE_STATIC_ADDRESS,
address_with_type=common.BluetoothAddressWithType(
address=common.BluetoothAddress(
address=bytes(b'C0:05:04:03:02:01')),
type=common.RANDOM_DEVICE_ADDRESS),
rotation_irk=
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
minimum_rotation_time=0,
maximum_rotation_time=0)
self.cert.hci_le_initiator_address.SetPrivacyPolicyForInitiatorAddress(
cert_privacy_policy)
with EventStream(
# DUT Scans
self.dut.hci_le_scanning_manager.StartScan(
empty_proto.Empty())) as advertising_event_stream:
# CERT Advertises
gap_name = hci_packets.GapData()
gap_name.data_type = hci_packets.GapDataType.COMPLETE_LOCAL_NAME
gap_name.data = list(bytes(b'Im_The_CERT!'))
gap_data = le_advertising_facade.GapDataMsg(
data=bytes(gap_name.Serialize()))
config = le_advertising_facade.AdvertisingConfig(
advertisement=[gap_data],
interval_min=512,
interval_max=768,
event_type=le_advertising_facade.AdvertisingEventType.ADV_IND,
address_type=common.RANDOM_DEVICE_ADDRESS,
channel_map=7,
filter_policy=le_advertising_facade.AdvertisingFilterPolicy.
ALL_DEVICES)
request = le_advertising_facade.CreateAdvertiserRequest(
config=config)
create_response = self.cert.hci_le_advertising_manager.CreateAdvertiser(
request)
advertising_event_stream.assert_event_occurs(
lambda packet: b'Im_The_CERT' in packet.event)
remove_request = le_advertising_facade.RemoveAdvertiserRequest(
advertiser_id=create_response.advertiser_id)
self.cert.hci_le_advertising_manager.RemoveAdvertiser(
remove_request)
def test_assert_occurs_at_most_passes(self):
with EventStream(FetchEvents(events=[1, 2, 3, 4],
delay_ms=50)) as event_stream:
event_stream.assert_event_occurs_at_most(
lambda data: data.value_ < 4,
timeout=timedelta(seconds=1),
at_most_times=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_assert_occurs_at_least_passes(self):
with EventStream(FetchEvents(events=[1, 2, 3, 1, 2, 3],
delay_ms=40)) as event_stream:
event_stream.assert_event_occurs(
lambda data: data.value_ == 1,
timeout=timedelta(milliseconds=300),
at_least_times=2)
def __init__(self, device):
logging.info("DUT: Init")
self._device = device
self._device.wait_channel_ready()
self._ui_event_stream = EventStream(
self._device.security.FetchUiEvents(empty_proto.Empty()))
self._bond_event_stream = EventStream(
self._device.security.FetchBondEvents(empty_proto.Empty()))
self._enforce_security_policy_stream = EventStream(
self._device.security.FetchEnforceSecurityPolicyEvents(
empty_proto.Empty()))
self._disconnect_event_stream = EventStream(
self._device.security.FetchDisconnectEvents(empty_proto.Empty()))
self._oob_data_event_stream = EventStream(
self._device.security.FetchGetOutOfBandDataEvents(
empty_proto.Empty()))
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 __init__(self, grpc_port, grpc_root_server_port, signal_port, cmd,
label, serial_number):
super().__init__(grpc_port, grpc_root_server_port, signal_port, cmd,
label, ACTS_CONTROLLER_CONFIG_NAME, serial_number)
# Facade stubs
self.rootservice = facade_rootservice_pb2_grpc.RootFacadeStub(
self.grpc_root_server_channel)
self.hal = hal_facade_pb2_grpc.HciHalFacadeStub(self.grpc_channel)
self.controller_read_only_property = facade_rootservice_pb2_grpc.ReadOnlyPropertyStub(
self.grpc_channel)
self.hci = hci_facade_pb2_grpc.HciLayerFacadeStub(self.grpc_channel)
self.hci.register_for_events = self.__register_for_hci_events
self.hci.new_event_stream = lambda: EventStream(self.hci.FetchEvents(empty_proto.Empty()))
self.hci.send_command_with_complete = self.__send_hci_command_with_complete
self.hci.send_command_with_status = self.__send_hci_command_with_status
self.l2cap = l2cap_facade_pb2_grpc.L2capClassicModuleFacadeStub(
self.grpc_channel)
self.hci_acl_manager = acl_manager_facade_pb2_grpc.AclManagerFacadeStub(
self.grpc_channel)
self.hci_le_acl_manager = le_acl_manager_facade_pb2_grpc.LeAclManagerFacadeStub(
self.grpc_channel)
self.hci_controller = controller_facade_pb2_grpc.ControllerFacadeStub(
self.grpc_channel)
self.hci_controller.GetMacAddressSimple = lambda : self.hci_controller.GetMacAddress(empty_proto.Empty()).address
self.hci_controller.GetLocalNameSimple = lambda : self.hci_controller.GetLocalName(empty_proto.Empty()).name
self.hci_le_advertising_manager = le_advertising_manager_facade_pb2_grpc.LeAdvertisingManagerFacadeStub(
self.grpc_channel)
self.hci_le_scanning_manager = le_scanning_manager_facade_pb2_grpc.LeScanningManagerFacadeStub(
self.grpc_channel)
self.neighbor = neighbor_facade_pb2_grpc.NeighborFacadeStub(
self.grpc_channel)
self.security = security_facade_pb2_grpc.SecurityModuleFacadeStub(
self.grpc_channel)
class PyAclManagerAclConnection(IEventStream, Closable):
def __init__(self, acl_manager, remote_addr, handle, event_stream):
self.acl_manager = acl_manager
self.handle = handle
self.remote_addr = remote_addr
self.connection_event_stream = event_stream
self.acl_stream = EventStream(
self.acl_manager.FetchAclData(
acl_manager_facade.HandleMsg(handle=self.handle)))
def disconnect(self, reason):
packet_bytes = bytes(
hci_packets.DisconnectBuilder(self.handle, reason).Serialize())
self.acl_manager.ConnectionCommand(
acl_manager_facade.ConnectionCommandMsg(packet=packet_bytes))
def close(self):
safeClose(self.connection_event_stream)
safeClose(self.acl_stream)
def wait_for_disconnection_complete(self):
disconnection_complete = HciCaptures.DisconnectionCompleteCapture()
assertThat(self.connection_event_stream).emits(disconnection_complete)
self.disconnect_reason = disconnection_complete.get().GetReason()
def send(self, data):
self.acl_manager.SendAclData(
acl_manager_facade.AclData(handle=self.handle,
payload=bytes(data)))
def get_event_queue(self):
return self.acl_stream.get_event_queue()
def __init__(self, device, acl_stream, remote_addr, handle):
"""
An abstract representation for an LE ACL connection in GD certification test
:param device: The GD device
:param acl_stream: The ACL stream for this connection
:param remote_addr: Remote device address
:param handle: Connection handle
"""
self.device = device
self.handle = handle
# todo enable filtering after sorting out handles
#self.our_acl_stream = FilteringEventStream(acl_stream, None)
self.our_acl_stream = acl_stream
if remote_addr:
remote_addr_bytes = bytes(
remote_addr.address.address,
'utf8') if type(remote_addr.address.address) is str else bytes(remote_addr.address.address)
self.connection_event_stream = EventStream(
self.device.hci_le_acl_manager.CreateConnection(
le_acl_manager_facade.LeConnectionMsg(
address_type=int(remote_addr.type),
address=remote_addr_bytes)))
else:
self.connection_event_stream = None
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 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 test_le_ad_scan_dut_advertises(self):
self.register_for_le_event(hci_packets.SubeventCode.ADVERTISING_REPORT)
self.register_for_le_event(
hci_packets.SubeventCode.EXTENDED_ADVERTISING_REPORT)
with EventStream(self.cert.hci.FetchLeSubevents(
empty_proto.Empty())) as hci_le_event_stream:
# CERT Scans
self.enqueue_hci_command(
hci_packets.LeSetRandomAddressBuilder('0C:05:04:03:02:01'),
True)
scan_parameters = hci_packets.PhyScanParameters()
scan_parameters.le_scan_type = hci_packets.LeScanType.ACTIVE
scan_parameters.le_scan_interval = 40
scan_parameters.le_scan_window = 20
self.enqueue_hci_command(
hci_packets.LeSetExtendedScanParametersBuilder(
hci_packets.OwnAddressType.RANDOM_DEVICE_ADDRESS,
hci_packets.LeScanningFilterPolicy.ACCEPT_ALL, 1,
[scan_parameters]), True)
self.enqueue_hci_command(
hci_packets.LeSetExtendedScanEnableBuilder(
hci_packets.Enable.ENABLED,
hci_packets.FilterDuplicates.DISABLED, 0, 0), True)
# DUT Advertises
gap_name = hci_packets.GapData()
gap_name.data_type = hci_packets.GapDataType.COMPLETE_LOCAL_NAME
gap_name.data = list(bytes(b'Im_The_DUT'))
gap_data = le_advertising_facade.GapDataMsg(
data=bytes(gap_name.Serialize()))
config = le_advertising_facade.AdvertisingConfig(
advertisement=[gap_data],
interval_min=512,
interval_max=768,
event_type=le_advertising_facade.AdvertisingEventType.ADV_IND,
address_type=common.RANDOM_DEVICE_ADDRESS,
channel_map=7,
filter_policy=le_advertising_facade.AdvertisingFilterPolicy.
ALL_DEVICES)
request = le_advertising_facade.CreateAdvertiserRequest(
config=config)
create_response = self.dut.hci_le_advertising_manager.CreateAdvertiser(
request)
hci_le_event_stream.assert_event_occurs(
lambda packet: b'Im_The_DUT' in packet.event)
remove_request = le_advertising_facade.RemoveAdvertiserRequest(
advertiser_id=create_response.advertiser_id)
self.dut.hci_le_advertising_manager.RemoveAdvertiser(
remove_request)
self.enqueue_hci_command(
hci_packets.LeSetScanEnableBuilder(
hci_packets.Enable.DISABLED, hci_packets.Enable.DISABLED),
True)
def test_assertThat_eventStream_emits_fails(self):
try:
with EventStream(FetchEvents(events=[1, 2, 3],
delay_ms=50)) as event_stream:
assertThat(event_stream).emits(lambda data: data.value_ == 4)
except Exception as e:
logging.debug(e)
return True # Failed as expected
return False
def test_assertThat_emitsNone_zero_fails(self):
try:
with EventStream(FetchEvents(events=[17],
delay_ms=50)) as event_stream:
assertThat(event_stream).emitsNone(timeout=timedelta(seconds=1))
except Exception as e:
logging.debug(e)
return True # Failed as expected
return False
def test_assert_occurs_fails(self):
try:
with EventStream(FetchEvents(events=[1, 2, 3],
delay_ms=50)) as event_stream:
event_stream.assert_event_occurs(
lambda data: data.value_ == 4, timeout=timedelta(seconds=1))
except Exception as e:
logging.debug(e)
return True # Failed as expected
return False
class InquirySession(Closable, IEventStream):
def __init__(self, device, inquiry_msg):
self.inquiry_event_stream = EventStream(
device.neighbor.SetInquiryMode(inquiry_msg))
def get_event_queue(self):
return self.inquiry_event_stream.get_event_queue()
def close(self):
safeClose(self.inquiry_event_stream)
def __init__(self, device):
"""
LE ACL Manager for GD Certification test
:param device: The GD device
"""
self.device = device
self.le_acl_stream = EventStream(
self.device.hci_le_acl_manager.FetchAclData(empty_proto.Empty()))
self.incoming_connection_stream = None
