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