def setup_class(self): self.droid_ad = self.android_devices[0] for ad in self.android_devices: bt_test_utils.clear_bonded_devices(ad) self.userid_1 = users.create_new_user(self.droid_ad, "testUser") self.userid_2 = users.create_new_user(self.droid_ad, "testUser2")
def test_le_pairing(self): """Test LE pairing transport stress This will test LE pairing between two android devices. Steps: 1. Start an LE advertisement on secondary device. 2. Find address from primary device. 3. Discover and bond to LE address. 4. Stop LE advertisement on secondary device. 5. Repeat steps 1-4 100 times Expected Result: LE pairing should pass 100 times. Returns: Pass if True Fail if False TAGS: LE, Scanning, Stress, Pairing Priority: 1 """ iterations = 100 for i in range(iterations): try: target_address, adv_callback, scan_callback = get_mac_address_of_generic_advertisement( self.scn_ad, self.adv_ad) except BtTestUtilsError as err: self.log.error(err) return False self.log.info("Begin interation {}/{}".format(i + 1, iterations)) self.scn_ad.droid.bluetoothStartPairingHelper() self.adv_ad.droid.bluetoothStartPairingHelper() start_time = self.start_timer() self.scn_ad.droid.bluetoothDiscoverAndBond(target_address) if not self._verify_successful_bond(target_address): self.log.error("Failed to bond devices.") return False self.log.info("Total time (ms): {}".format(self.end_timer())) if not clear_bonded_devices(self.scn_ad): self.log.error("Failed to unbond device from scanner.") return False if not clear_bonded_devices(self.adv_ad): self.log.error("Failed to unbond device from advertiser.") return False self.adv_ad.droid.bleStopBleAdvertising(adv_callback) self.scn_ad.droid.bleStopBleScan(scan_callback) # Magic sleep to let unbonding finish time.sleep(2) return True
def setup_test(self): for a in self.android_devices: if not clear_bonded_devices(a): return False for a in self.android_devices: a.ed.clear_all_events() return True
def setup_class(self): self.ad.droid.bluetoothFactoryReset() # Factory reset requires a short delay to take effect time.sleep(3) self.ad.log.info("Making sure BT phone is enabled here during setup") if not bluetooth_enabled_check(self.ad): self.log.error("Failed to turn Bluetooth on DUT") # Give a breathing time of short delay to take effect time.sleep(3) reset_bluetooth([self.ad]) # Determine if we have a relay-based device if hasattr(self, 'relay_devices'): for headphone in self.relay_devices: headphone.setup() ''' # Turn of the Power Supply for the headphones. if hasattr(self, 'relay_devices'): power_supply = self.relay_devices[0] power_supply.power_off() ''' super(HeadphoneTest, self).setup_class() return clear_bonded_devices(self.ad)
def setup_test(self): for a in self.android_devices: if not clear_bonded_devices(a): return False self.log.debug(log_energy_info(self.android_devices, "Start")) for a in self.android_devices: a.ed.clear_all_events() return True
def setup_test(self): # Reset bluetooth reset_bluetooth(self.android_devices) for ad in self.android_devices: if not clear_bonded_devices(ad): logging.error("Failed to unbound device") return False # Sync device time for timestamp comparison sync_device_time(ad) return super(BtMetricsTest, self).setup_test()
def teardown_class(self): if self.headphone_list is not None: for headphone in self.headphone_list: headphone.power_off() headphone.clean_up() ''' power_supply = self.relay_devices[0] power_supply.power_off() ''' return clear_bonded_devices(self.ad)
def test_pair_unpair_stress(self): """ Stress Test for Pairing and Unpairing of Bluetooth Headphones. Steps: 1. Pairing and Connect Bluetooth headset. 2. Disconnect Bleutooth Headset. 3. Repeat step 1-2 for 10 iterations. Expected Result: Bluetooth pairing and unpairing should succeed. Returns: Pass if True Fail if False TAGS: Classic, Stress Priority: 1 """ for n in range(self.iterations): self.log.info("Pair headphone iteration %s.", (n + 1)) for headphone in self.headphone_list: if self._discover_and_pair(headphone) is False: # The device is probably not in pairing mode, put in pairing mode. headphone.turn_power_on_and_enter_pairing_mode() time.sleep(6) if self._discover_and_pair(headphone) is False: # Device must be on, but not in pairing mode. headphone.power_off() headphone.turn_power_on_and_enter_pairing_mode() time.sleep(6) msg = "Unable to pair to %s", headphone.name assert_true(self._discover_and_pair(headphone), msg) if len(self.ad.droid.bluetoothGetConnectedDevices()) == 0: self.log.error("Not connected to relay based device.") return False clear_bonded_devices(self.ad)
def test_pair_bluetooth_stress(self): """Stress test for pairing BT devices. Test the integrity of Bluetooth pairing. 1. Primary device discover the secondary device 2. Primary device tries to pair to secondary device 3. Pair two devices after verifying pin number on both devices are equal 4. Verify both devices are paired 5. Unpair devices. 6. Verify devices unpaired. 7. Repeat steps 1-6 100 times. Expected Result: Each iteration of toggling Bluetooth pairing and unpairing should succeed. Returns: Pass if True Fail if False TAGS: Classic, Stress Priority: 1 """ for n in range(self.iterations): self.log.info("Pair bluetooth iteration {}.".format(n + 1)) self.start_timer() if (not pair_pri_to_sec(self.android_devices[0], self.android_devices[1], attempts=1, auto_confirm=False)): self.log.error("Failed to bond devices.") return False self.log.info("Total time (ms): {}".format(self.end_timer())) # A device bond will trigger a number of system routines that need # to settle before unbond time.sleep(2) for ad in self.android_devices: if not clear_bonded_devices(ad): return False # Necessary sleep time for entries to update unbonded state time.sleep(2) bonded_devices = ad.droid.bluetoothGetBondedDevices() if len(bonded_devices) > 0: self.log.error( "Failed to unbond devices: {}".format(bonded_devices)) return False return True
def test_pair_and_unpair_bt_device(self): """ Test Pairing and Unpairing Bluetooth Headphones to the Android device. Steps: 1. Pair and Connect Bluetooth headset. 2. Disconnect Bleutooth Headset. Expected Result: Bluetooth pairing and unpairing should succeed. Returns: Pass if True Fail if False TAGS: Classic. Priority: 0 """ for headphone in self.headphone_list: self.log.info("Start testing on " + headphone.name) if self._discover_and_pair(headphone) is False: # The device is probably not in pairing mode, put in pairing mode. headphone.turn_power_on_and_enter_pairing_mode() time.sleep(6) if self._discover_and_pair(headphone) is False: # Device must be on, but not in pairing mode. headphone.power_off() headphone.turn_power_on_and_enter_pairing_mode() time.sleep(6) msg = "Unable to pair to %s", headphone.name assert_true(self._discover_and_pair(headphone), msg) if len(self.ad.droid.bluetoothGetConnectedDevices()) == 0: self.log.error("Not connected to relay based device.") return False clear_bonded_devices(self.ad)
def test_pair_bluetooth_stress(self): """Stress test for pairing BT devices. Test the integrity of Bluetooth pairing. Steps: 1. Pair two Android devices 2. Verify both devices are paired 3. Unpair devices. 4. Verify devices unpaired. 5. Repeat steps 1-4 100 times. Expected Result: Each iteration of toggling Bluetooth pairing and unpairing should succeed. Returns: Pass if True Fail if False TAGS: Classic, Stress Priority: 1 """ for n in range(self.iterations): self.log.info("Pair bluetooth iteration {}.".format(n + 1)) self.start_timer() if (not pair_pri_to_sec(self.android_devices[0].droid, self.android_devices[1].droid)): self.log.error("Failed to bond devices.") return False self.log.info("Total time (ms): {}".format(self.end_timer())) for ad in self.android_devices: if not clear_bonded_devices(ad): return False # Necessary sleep time for entries to update unbonded state time.sleep(1) bonded_devices = ad.droid.bluetoothGetBondedDevices() if len(bonded_devices) > 0: self.log.error("Failed to unbond devices: {}".format( bonded_devices)) return False return True
def setup_test(self): for a in self.android_devices: if not clear_bonded_devices(a): return False for a in self.android_devices: a.ed.clear_all_events() i = 0 while not self.device_ad.droid.bluetoothHidDeviceIsReady(): time.sleep(1) i += 1 self.log.info("BluetoothHidDevice NOT Ready") if i == 10: return False if not self.device_ad.droid.bluetoothHidDeviceRegisterApp(): self.log.error("Device: registration failed") return False self.log.info("Device: registration done") return True
def teardown_test(self): super(BluetoothBaseTest, self).teardown_test() self.dongle.clean_up() clear_bonded_devices(self.dut) return True
def teardown_test(self): clear_bonded_devices(self.pri_ad) CoexBaseTest.teardown_test(self) self.audio_receiver.clean_up()
def test_pairing_metric(self): """Test if a pairing event generates the correct metric entry This test tries to pair two Bluetooth devices and dumps metrics after pairing. A correctly implemented stack should record 8 pairing events. Steps: 1. Start pairing between two Bluetooth devices 2. After pairing is done, dump and parse the metrics 3. Compare the number of pairing events and the time stamp of the pairing event Expected Result: No errors, 8 pairing events should be generated Returns: Pass if True Fail if False TAGS: Classic Priority: 1 """ time_bonds = [] for n in range(self.iterations): start_time = get_current_epoch_time() self.log.info("Pair bluetooth iteration {}.".format(n + 1)) if (not pair_pri_to_sec(self.android_devices[0], self.android_devices[1], attempts=1, auto_confirm=False)): self.log.error("Failed to bond devices.") return False end_time = get_current_epoch_time() time_bonds.append((start_time, end_time)) # A device bond will trigger a number of system routines that need # to settle before unbond time.sleep(2) for ad in self.android_devices: if not clear_bonded_devices(ad): return False # Necessary sleep time for entries to update unbonded state time.sleep(2) bonded_devices = ad.droid.bluetoothGetBondedDevices() if len(bonded_devices) > 0: self.log.error( "Failed to unbond devices: {}".format(bonded_devices)) return False end_time = get_current_epoch_time() bluetooth_logs, bluetooth_logs_ascii = \ self.collect_bluetooth_manager_metrics_logs( [self.android_devices[0]]) bluetooth_log = bluetooth_logs[0] bluetooth_log_ascii = bluetooth_logs_ascii[0] asserts.assert_equal(len(bluetooth_log.pair_event), 8, extras=bluetooth_log_ascii) for pair_event in bluetooth_log.pair_event: t = pair_event.event_time_millis asserts.assert_true( start_time <= t <= end_time, "Event time %d not within limit [%d, %d]" % (t, start_time, end_time)) device_info = pair_event.device_paired_with asserts.assert_true(device_info, "Device info is none") asserts.assert_equal( device_info.device_type, self.android_devices[0]. bluetooth_proto_module.DeviceInfo.DEVICE_TYPE_BREDR, "Device type does not match")
def teardown_test(self): clear_bonded_devices(self.pri_ad) super().teardown_test() self.audio_receiver.clean_up()
def teardown_test(self): clear_bonded_devices(self.pri_ad) super().teardown_test()
def test_repairing(self): """ Tests that even if we modify the priorities, on unpair and pair we will reset the priorities. Steps: 1. Pair the devices (do not connect) 2. Unset the priorities for HFP and A2DP 3. Pair again 4. Check the priorities, they should be set to default. Returns: Pass if True Fail if False Priority: 0 """ # Pair the devices. self.log.info("Pairing the devices ...") if not bt_test_utils.pair_pri_to_sec( self.car, self.ph, attempts=1, auto_confirm=False): self.log.error("Failed to pair devices.") return False # Timed wait for the profile priorities to propagate. time.sleep(BOND_TO_SDP_WAIT) # Set the priority to OFF for ALL car profiles. self.car.log.info("Set priorities off ...") car_bt_utils.set_car_profile_priorities_off(self.car, self.ph) # Now unpair the devices. self.log.info("Resetting the devices ...") for ad in self.android_devices: bt_test_utils.clear_bonded_devices(ad) # Give the stack time to unbond. time.sleep(UNBOND_TIMEOUT) # Pair them again! self.log.info("Pairing them again ...") if not bt_test_utils.pair_pri_to_sec( self.car, self.ph, attempts=1, auto_confirm=False): self.log.error("Faild to pair devices.") return False # Timed wait for the profile priorities to propagate. time.sleep(BOND_TO_SDP_WAIT) # Check the default priorities. ph_hfp_p = self.car.droid.bluetoothHfpClientGetPriority( self.ph.droid.bluetoothGetLocalAddress()) if ph_hfp_p != BtEnum.BluetoothPriorityLevel.PRIORITY_ON.value: self.hf.log.error("HFP priority found: {}, expected: {}.".format( ph_hfp_p, BtEnum.BluetoothPriorityLevel.PRIORITY_ON.value)) return False ph_a2dp_p = self.car.droid.bluetoothA2dpSinkGetPriority( self.ph.droid.bluetoothGetLocalAddress()) if ph_a2dp_p != BtEnum.BluetoothPriorityLevel.PRIORITY_ON.value: self.ph.log.error("A2DP priority found: {}, expected {}.".format( ph_a2dp_p, BtEnum.BluetoothPriorityLevel.PRIORITY_ON.value)) return False return True
def teardown_test(self): for ad in self.android_devices: bt_test_utils.clear_bonded_devices(ad) # Give the stack time to unbond. time.sleep(UNBOND_TIMEOUT)
def setup_class(self): self.droid_ad = self.android_devices[0] for ad in self.android_devices: bt_test_utils.clear_bonded_devices(ad)
def test_gatt_connect_mitm_attack(self): """Test GATT connection with permission write encrypted mitm. Test establishing a gatt connection between a GATT server and GATT client while the GATT server's characteristic includes the property write value and the permission write encrypted mitm value. This will prompt LE pairing and then the devices will create a bond. Steps: 1. Create a GATT server and server callback on the peripheral device. 2. Create a unique service and characteristic uuid on the peripheral. 3. Create a characteristic on the peripheral with these properties: gatt_characteristic['property_write'], gatt_characteristic['permission_write_encrypted_mitm'] 4. Create a GATT service on the peripheral. 5. Add the characteristic to the GATT service. 6. Create a GATT connection between your central and peripheral device. 7. From the central device, discover the peripheral's services. 8. Iterate the services found until you find the unique characteristic created in step 3. 9. Once found, write a random but valid value to the characteristic. 10. Start pairing helpers on both devices immediately after attempting to write to the characteristic. 11. Within 10 seconds of writing the characteristic, there should be a prompt to bond the device from the peripheral. The helpers will handle the UI interaction automatically. (see BluetoothConnectionFacade.java bluetoothStartPairingHelper). 12. Verify that the two devices are bonded. Expected Result: Verify that a connection was established and the devices are bonded. Returns: Pass if True Fail if False TAGS: LE, Advertising, Filtering, Scanning, GATT, Characteristic, MITM Priority: 1 """ gatt_server_cb = self.per_ad.droid.gattServerCreateGattServerCallback() gatt_server = self.per_ad.droid.gattServerOpenGattServer( gatt_server_cb) self.gatt_server_list.append(gatt_server) service_uuid = "3846D7A0-69C8-11E4-BA00-0002A5D5C51B" test_uuid = "aa7edd5a-4d1d-4f0e-883a-d145616a1630" bonded = False characteristic = self.per_ad.droid.gattServerCreateBluetoothGattCharacteristic( test_uuid, gatt_characteristic['property_write'], gatt_characteristic['permission_write_encrypted_mitm']) gatt_service = self.per_ad.droid.gattServerCreateService( service_uuid, gatt_service_types['primary']) self.per_ad.droid.gattServerAddCharacteristicToService(gatt_service, characteristic) self.per_ad.droid.gattServerAddService(gatt_server, gatt_service) result = self._find_service_added_event(gatt_server_cb, service_uuid) if not result: return False bluetooth_gatt, gatt_callback, adv_callback = ( orchestrate_gatt_connection(self.cen_ad, self.per_ad)) self.bluetooth_gatt_list.append(bluetooth_gatt) self.adv_instances.append(adv_callback) if self.cen_ad.droid.gattClientDiscoverServices(bluetooth_gatt): expected_event = gatt_cb_strings['gatt_serv_disc'].format( gatt_callback) try: event = self.cen_ad.ed.pop_event(expected_event, self.default_timeout) except Empty: self.log.error(gatt_cb_err['gatt_serv_disc'].format( expected_event)) return False discovered_services_index = event['data']['ServicesIndex'] else: self.log.info("Failed to discover services.") return False test_value = [1, 2, 3, 4, 5, 6, 7] services_count = self.cen_ad.droid.gattClientGetDiscoveredServicesCount( discovered_services_index) for i in range(services_count): characteristic_uuids = ( self.cen_ad.droid.gattClientGetDiscoveredCharacteristicUuids( discovered_services_index, i)) for characteristic_uuid in characteristic_uuids: if characteristic_uuid == test_uuid: self.cen_ad.droid.bluetoothStartPairingHelper() self.per_ad.droid.bluetoothStartPairingHelper() self.cen_ad.droid.gattClientCharacteristicSetValue( bluetooth_gatt, discovered_services_index, i, characteristic_uuid, test_value) self.cen_ad.droid.gattClientWriteCharacteristic( bluetooth_gatt, discovered_services_index, i, characteristic_uuid) start_time = time.time() + self.default_timeout target_name = self.per_ad.droid.bluetoothGetLocalName() while time.time() < start_time and bonded == False: bonded_devices = \ self.cen_ad.droid.bluetoothGetBondedDevices() for device in bonded_devices: if ('name' in device.keys() and device['name'] == target_name): bonded = True break bonded = False target_name = self.cen_ad.droid.bluetoothGetLocalName() while time.time() < start_time and bonded == False: bonded_devices = \ self.per_ad.droid.bluetoothGetBondedDevices() for device in bonded_devices: if ('name' in device.keys() and device['name'] == target_name): bonded = True break for ad in [self.cen_ad, self.per_ad]: if not clear_bonded_devices(ad): return False # Necessary sleep time for entries to update unbonded state time.sleep(2) bonded_devices = ad.droid.bluetoothGetBondedDevices() if len(bonded_devices) > 0: self.log.error("Failed to unbond devices: {}".format( bonded_devices)) return False return self._orchestrate_gatt_disconnection(bluetooth_gatt, gatt_callback)