| # Lint as: python2, python3 |
| # Copyright 2021 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """A Batch of Bluetooth LE LLT health tests""" |
| |
| from autotest_lib.server.cros.bluetooth import advertisements_data |
| |
| DEFAULT_MIN_ADV_INTERVAL = 200 |
| DEFAULT_MAX_ADV_INTERVAL = 500 |
| |
| from autotest_lib.server.cros.bluetooth.\ |
| bluetooth_adapter_controller_role_tests \ |
| import bluetooth_AdapterControllerRoleTests |
| from autotest_lib.server.cros.bluetooth.bluetooth_adapter_quick_tests \ |
| import BluetoothAdapterQuickTests |
| from autotest_lib.server.cros.bluetooth.bluetooth_adapter_hidreports_tests \ |
| import BluetoothAdapterHIDReportTests |
| from autotest_lib.server.cros.bluetooth.bluetooth_adapter_better_together \ |
| import BluetoothAdapterBetterTogether |
| |
| |
| class bluetooth_AdapterLLTHealth(BluetoothAdapterHIDReportTests, |
| bluetooth_AdapterControllerRoleTests, |
| BluetoothAdapterBetterTogether): |
| """A Batch of Bluetooth LE LLT health tests. This test is written |
| as a batch of tests in order to reduce test time, since auto-test |
| ramp up time is costly. The batch is using BluetoothAdapterQuickTests |
| wrapper methods to start and end a test and a batch of tests. |
| |
| This class can be called to run the entire test batch or to run a |
| specific test only |
| """ |
| |
| test_wrapper = BluetoothAdapterQuickTests.quick_test_test_decorator |
| batch_wrapper = BluetoothAdapterQuickTests.quick_test_batch_decorator |
| |
| |
| def discover_and_pair(self, device): |
| """Discovers and pairs given device. Automatically connects too. |
| |
| @param device: meta object for bt peer device |
| """ |
| self.test_discover_device(device.address) |
| self.test_pairing(device.address, device.pin, trusted=True) |
| self.test_connection_by_adapter(device.address) |
| |
| |
| def start_connectable_advertisement(self): |
| """ Initiate connectable advertising from DUT """ |
| # Register and start advertising instance |
| # We ignore failure because the test isn't able to verify |
| # the min/max advertising intervals, but this is ok. |
| self.test_reset_advertising() |
| self.test_set_advertising_intervals(DEFAULT_MIN_ADV_INTERVAL, |
| DEFAULT_MAX_ADV_INTERVAL) |
| self.test_register_advertisement(advertisements_data.ADVERTISEMENTS[0], |
| 1) |
| |
| |
| def pair_and_test_central(self, peripheral): |
| """Connects DUT as central to a peripheral device. |
| |
| @param peripheral: meta object for bt peer device |
| """ |
| # Pair the central device first - |
| # necessary for later connection to peripheral |
| self.pair_adapter_to_device(peripheral) |
| self.test_device_set_discoverable(peripheral, False) |
| |
| self.start_connectable_advertisement() |
| # Discover DUT from peer |
| self.test_discover_by_device(peripheral) |
| # Connect to DUT from peer, putting DUT in peripheral role |
| self.test_connection_by_device(peripheral) |
| self.test_reset_advertising() |
| |
| |
| @test_wrapper('LLT: 1 Central 1 Peripheral. Order of connection CP', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1 |
| }) |
| def llt_1c1p_connect_cp(self): |
| """Tests llt with two peer devices. |
| Connects DUT as central to first device |
| and as peripheral to second device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| # Establish connection from DUT as LE Central |
| self.discover_and_pair(central) |
| |
| self.test_hid_device_created(central.address) |
| # Verify data transfer over the DUT LE central Connection |
| self.test_mouse_left_click(central) |
| |
| # Now establish second connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Verify data over LE Central connection again |
| self.test_mouse_left_click(central) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central.address) |
| self.test_disconnection_by_device(peripheral) |
| |
| |
| @test_wrapper('LLT: 1 Central 1 Peripheral. Order of connection PC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1 |
| }) |
| def llt_1c1p_connect_pc(self): |
| """Tests llt with two peer devices, |
| Connects DUT as peripheral to first device |
| and as central to second device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| # Establish the first connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Establish second connection from DUT as LE Central |
| self.discover_and_pair(central) |
| self.test_hid_device_created(central.address) |
| # Verify data transfer over the DUT LE Central Connection |
| self.test_mouse_left_click(central) |
| # Verfiy LE peripheral connection again |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central.address) |
| self.test_disconnection_by_device(peripheral) |
| |
| |
| @test_wrapper('LLT: 1 Central 1 Peripheral while DUT advertising.' |
| 'Order of connection PC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1 |
| }) |
| def llt_1c1p_connect_pc_while_adv(self): |
| """Tests llt with two peer devices, while DUT advertising. |
| Connects DUT while advertising |
| as peripheral to first device |
| and as central to second device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| # Establish the first connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Establish second connection from DUT as LE Central |
| # while advertising in progress |
| self.start_connectable_advertisement() |
| self.discover_and_pair(central) |
| self.test_hid_device_created(central.address) |
| |
| # Verify data transfer over the DUT LE Central Connection |
| self.test_mouse_left_click(central) |
| # Verfiy LE Peripheral connection again |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central.address) |
| self.test_disconnection_by_device(peripheral) |
| self.test_reset_advertising() |
| |
| |
| @test_wrapper('LLT: 2 Central 1 Peripheral. Order of connection CCP', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2c1p_connect_ccp(self): |
| """Tests llt with three peer devices. |
| Connects DUT as central to first and second devices, |
| connects DUT as peripheral to third device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central_1 = self.devices['BLE_PHONE'][0] |
| central_2 = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| # Establish two connections from DUT as LE Central |
| self.discover_and_pair(central_2) |
| self.test_hid_device_created(central_2.address) |
| |
| # Verify data transfer over two DUT LE Central Connections |
| self.test_mouse_left_click(central_2) |
| |
| central_1.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_1.address) |
| |
| # Establish third connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Verify data transfer over two DUT LE Central Connections |
| self.test_mouse_left_click(central_2) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_1.address) |
| self.test_disconnection_by_adapter(central_2.address) |
| self.test_disconnection_by_device(peripheral) |
| |
| |
| @test_wrapper('LLT: 2 Central 1 Peripheral. Order of connection PCC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2c1p_connect_pcc(self): |
| """Tests llt with three peer devices. |
| Connects DUT as peripheral to first device |
| and as central to second and third device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central_1 = self.devices['BLE_PHONE'][0] |
| central_2 = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| |
| # Establish the first connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Establish connections from DUT as LE Central |
| self.discover_and_pair(central_2) |
| self.test_hid_device_created(central_2.address) |
| |
| # Verify data transfer over two DUT LE Central Connections |
| self.test_mouse_left_click(central_2) |
| |
| # Establish third connection |
| central_1.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_1.address) |
| |
| # Verify once again data transfer over DUT LE Peripheral connection |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_1.address) |
| self.test_disconnection_by_adapter(central_2.address) |
| self.test_disconnection_by_device(peripheral) |
| |
| |
| @test_wrapper('LLT: 2 Central 1 Peripheral. Order of connection CPC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2c1p_connect_cpc(self): |
| """Tests llt with three peer devices. |
| Connects DUT as central to first device, |
| as peripheral to second and as central to third device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central_1 = self.devices['BLE_PHONE'][0] |
| central_2 = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| |
| # Establish the first connection with DUT as LE Central |
| central_1.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_1.address) |
| |
| # Establish the second connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Establish third connections from DUT as LE Central |
| self.discover_and_pair(central_2) |
| self.test_hid_device_created(central_2.address) |
| |
| # Verify data transfer over second LE Central Connections |
| self.test_mouse_left_click(central_2) |
| # Verify once again data transfer over DUT LE Peripheral connection |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_1.address) |
| self.test_disconnection_by_adapter(central_2.address) |
| self.test_disconnection_by_device(peripheral) |
| |
| |
| @test_wrapper('LLT: 2 Central 1 Peripheral while DUT advertising.' |
| 'Order of connection PCC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2c1p_connect_pcc_while_adv(self): |
| """Tests llt with three peer devices. |
| Connects DUT as peripheral to first device |
| and as central to second and third device while advertising, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central_1 = self.devices['BLE_MOUSE'][0] |
| central_2 = self.devices['BLE_PHONE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| |
| # Establish the first connection with DUT as LE Peripheral |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Connect as first LE Central while DUT is advertising |
| self.start_connectable_advertisement() |
| self.discover_and_pair(central_1) |
| self.test_hid_device_created(central_1.address) |
| |
| # Establish second LE connection from DUT as LE Central |
| central_2.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_2.address) |
| |
| # Verify data transfer over first LE Central Connections |
| self.test_mouse_left_click(central_1) |
| # Verify once again data transfer over DUT LE Peripheral connection |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_1.address) |
| self.test_disconnection_by_adapter(central_2.address) |
| self.test_disconnection_by_device(peripheral) |
| self.test_reset_advertising() |
| |
| |
| @test_wrapper('LLT: 2 Central 1 Peripheral while DUT Advertising.' |
| 'Order of connection CPC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2c1p_connect_cpc_while_adv(self): |
| """Tests llt with three peer devices. |
| Connects DUT while advertising as central to first device, |
| as peripheral to second and as central to third device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| central_1 = self.devices['BLE_PHONE'][0] |
| central_2 = self.devices['BLE_MOUSE'][0] |
| peripheral = self.devices['BLE_KEYBOARD'][0] |
| |
| self.bluetooth_le_facade = self.bluetooth_facade |
| # Establish the first connection with DUT as LE Central |
| # while advertising in progress |
| self.start_connectable_advertisement() |
| central_1.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_1.address) |
| |
| # Establish the second connection with DUT as LE Peripheral |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral) |
| self.run_keyboard_tests(peripheral) |
| |
| # Establish third connections from DUT as LE Central |
| self.discover_and_pair(central_2) |
| self.test_hid_device_created(central_2.address) |
| |
| # Verify data transfer over second LE Central Connections |
| self.test_mouse_left_click(central_2) |
| # Verify once again data transfer over DUT LE Peripheral connection |
| self.run_keyboard_tests(peripheral) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_1.address) |
| self.test_disconnection_by_adapter(central_2.address) |
| self.test_disconnection_by_device(peripheral) |
| self.test_reset_advertising() |
| |
| |
| @test_wrapper('LLT: 1 Central 2 Peripheral. Order of connection CPP', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2p1c_connect_cpp(self): |
| """Tests llt with three peer devices. |
| Connects DUT as central to first device |
| and as peripheral to second and third devices, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| peripheral_1 = self.devices['BLE_KEYBOARD'][0] |
| central_peer = self.devices['BLE_PHONE'][0] |
| peripheral_2 = self.devices['BLE_MOUSE'][0] |
| |
| # Establish connection from DUT as LE Central |
| central_peer.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_peer.address) |
| |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral_1) |
| self.run_keyboard_tests(peripheral_1) |
| |
| # Establish and Verify second LE peripheral connection |
| self.pair_and_test_central(peripheral_2) |
| |
| # Try transferring data over connection |
| self.test_mouse_left_click(peripheral_2) |
| # Verify traffic from LE Peripheral connections again |
| self.run_keyboard_tests(peripheral_1) |
| self.test_mouse_left_click(peripheral_2) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_peer.address) |
| self.test_disconnection_by_device(peripheral_1) |
| self.test_disconnection_by_device(peripheral_2) |
| |
| |
| @test_wrapper('LLT: 1 Central 2 Peripheral. Order of connection PCP', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2p1c_connect_pcp(self): |
| """Tests llt with three peer devices. |
| Connects DUT as peripheral to first device, |
| as central to second and as peripheral to third devices, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| peripheral_1 = self.devices['BLE_KEYBOARD'][0] |
| central_peer = self.devices['BLE_PHONE'][0] |
| peripheral_2 = self.devices['BLE_MOUSE'][0] |
| |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral_1) |
| self.run_keyboard_tests(peripheral_1) |
| |
| # Establish connection from DUT as LE Central |
| central_peer.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_peer.address) |
| |
| # Establish and Verify second LE peripheral connection |
| self.pair_and_test_central(peripheral_2) |
| |
| # Try transferring data over connection |
| self.test_mouse_left_click(peripheral_2) |
| # Verify traffic from LE Peripheral connections again |
| self.run_keyboard_tests(peripheral_1) |
| self.test_mouse_left_click(peripheral_2) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_peer.address) |
| self.test_disconnection_by_device(peripheral_1) |
| self.test_disconnection_by_device(peripheral_2) |
| |
| |
| @test_wrapper('LLT: 1 Central 2 Peripheral. Order of connection PPC', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1, |
| 'BLE_PHONE': 1 |
| }) |
| def llt_2p1c_connect_ppc(self): |
| """Tests llt with three peer devices. |
| Connects DUT as peripheral to first and second devices |
| and as central to third device, |
| sends small amount of data over the connection |
| """ |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral']) |
| |
| peripheral_1 = self.devices['BLE_KEYBOARD'][0] |
| central_peer = self.devices['BLE_PHONE'][0] |
| peripheral_2 = self.devices['BLE_MOUSE'][0] |
| |
| self.bluetooth_le_facade = self.bluetooth_facade |
| |
| # Connect to DUT from peer, putting DUT in peripheral role |
| # Try transferring data over connection |
| self.pair_and_test_central(peripheral_1) |
| self.run_keyboard_tests(peripheral_1) |
| |
| # Establish and Verify second LE peripheral connection |
| self.pair_and_test_central(peripheral_2) |
| |
| # Try transferring data over connection |
| self.test_mouse_left_click(peripheral_2) |
| |
| # Verify data transfer over two DUT LE Central Connections |
| central_peer.RemoveDevice(self.bluetooth_facade.address) |
| self.test_smart_unlock_llt(address=central_peer.address) |
| # Verify traffic from LE Peripheral connections again |
| self.run_keyboard_tests(peripheral_1) |
| self.test_mouse_left_click(peripheral_2) |
| |
| # Disconnect connections from DUT |
| self.test_disconnection_by_adapter(central_peer.address) |
| self.test_disconnection_by_device(peripheral_1) |
| self.test_disconnection_by_device(peripheral_2) |
| |
| |
| @batch_wrapper('LLT Health') |
| def llt_health_batch_run(self, num_iterations=1, test_name=None): |
| """Run the LE LLT health test batch or a specific given test. |
| The wrapper of this method is implemented in batch_decorator. |
| Using the decorator a test batch method can implement the only its |
| core tests invocations and let the decorator handle the wrapper, |
| which is taking care for whether to run a specific test or the |
| batch as a whole, and running the batch in iterations |
| |
| @param num_iterations: how many iterations to run |
| @param test_name: specific test to run otherwise None to run the |
| whole batch |
| """ |
| self.llt_1c1p_connect_cp() |
| self.llt_1c1p_connect_pc() |
| self.llt_1c1p_connect_pc_while_adv() |
| self.llt_2c1p_connect_ccp() |
| self.llt_2c1p_connect_pcc() |
| self.llt_2c1p_connect_cpc() |
| self.llt_2c1p_connect_pcc_while_adv() |
| self.llt_2c1p_connect_cpc_while_adv() |
| self.llt_2p1c_connect_cpp() |
| self.llt_2p1c_connect_pcp() |
| self.llt_2p1c_connect_ppc() |
| |
| |
| def run_once(self, |
| host, |
| num_iterations=1, |
| args_dict=None, |
| test_name=None, |
| flag='Quick Health'): |
| """Run the batch of Bluetooth LE LLT health tests |
| |
| @param host: the DUT, usually a chromebook |
| @param num_iterations: the number of rounds to execute the test |
| @test_name: the test to run, or None for all tests |
| """ |
| |
| # Initialize and run the test batch or the requested specific test |
| self.quick_test_init(host, |
| use_btpeer=True, |
| flag=flag, |
| args_dict=args_dict) |
| self.llt_health_batch_run(num_iterations, test_name) |
| self.quick_test_cleanup() |
