| # Copyright 2019 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 of Bluetooth LE health tests""" |
| |
| import time |
| |
| 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_pairing_tests import ( |
| BluetoothAdapterPairingTests) |
| from autotest_lib.server.cros.bluetooth.bluetooth_adapter_hidreports_tests \ |
| import BluetoothAdapterHIDReportTests |
| |
| |
| # TODO(b/161174805) - veyron_fievel and veyron_mickey experiencing an |
| # unexpected re-connect to peer, causing peer tests to fail. LE Role tests are |
| # being hit especially hard, so temporarily disabling these tests on veyron |
| LAB_VEYRON_MODELS = ['veyron_mickey', 'veyron_fievel'] |
| |
| class bluetooth_AdapterLEHealth(BluetoothAdapterQuickTests, |
| BluetoothAdapterPairingTests, |
| BluetoothAdapterHIDReportTests, |
| bluetooth_AdapterControllerRoleTests): |
| """A Batch of Bluetooth LE 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 |
| |
| @test_wrapper('Discovery Test', devices={"BLE_MOUSE":1}) |
| def le_discovery_test(self): |
| """Performs discovery test with mouse peripheral""" |
| device = self.devices['BLE_MOUSE'][0] |
| |
| self.test_discover_device(device.address) |
| |
| # Removed due to b:149093897 - the raspi peer can't instantly update |
| # the advertised name, causing this test to fail |
| # self.test_device_name(device.address, device.name) |
| |
| |
| @test_wrapper('Connect Disconnect Loop', devices={'BLE_MOUSE':1}) |
| def le_connect_disconnect_loop(self): |
| """Run connect/disconnect loop initiated by DUT. |
| The test also checks that there are no undesired |
| reconnections. |
| TODO(ysahvit) - add connection creation attempts |
| initiated by HID device |
| """ |
| |
| device = self.devices['BLE_MOUSE'][0] |
| self.connect_disconnect_loop(device=device, loops=3) |
| |
| @test_wrapper('Mouse Reports', devices={'BLE_MOUSE':1}) |
| def le_mouse_reports(self): |
| """Run all bluetooth mouse reports tests""" |
| |
| device = self.devices['BLE_MOUSE'][0] |
| # Let the adapter pair, and connect to the target device. |
| self.test_discover_device(device.address) |
| time.sleep(self.TEST_SLEEP_SECS) |
| self.test_pairing(device.address, device.pin, trusted=True) |
| |
| # With raspberry pi peer, it takes a moment before the device is |
| # registered as an input device. Without delay, the input recorder |
| # doesn't find the device |
| time.sleep(1) |
| self.run_mouse_tests(device=device) |
| |
| |
| @test_wrapper('Keyboard Reports', devices={'BLE_KEYBOARD':1}) |
| def le_keyboard_reports(self): |
| """Run all bluetooth keyboard reports tests""" |
| |
| device = self.devices['BLE_KEYBOARD'][0] |
| # Let the adapter pair, and connect to the target device. |
| self.test_discover_device(device.address) |
| time.sleep(self.TEST_SLEEP_SECS) |
| self.test_pairing(device.address, device.pin, trusted=True) |
| |
| # With raspberry pi peer, it takes a moment before the device is |
| # registered as an input device. Without delay, the input recorder |
| # doesn't find the device |
| time.sleep(1) |
| self.run_keyboard_tests(device=device) |
| |
| |
| @test_wrapper('Battery Reporting', devices={'BLE_MOUSE': 1}) |
| def battery_reporting(self): |
| """Run battery reporting tests""" |
| |
| device = self.devices['BLE_MOUSE'][0] |
| # Let the adapter pair, and connect to the target device. |
| self.assert_on_fail(self.test_discover_device(device.address)) |
| self.assert_on_fail( |
| self.test_pairing(device.address, device.pin, trusted=True)) |
| |
| self.run_battery_reporting_tests(device=device) |
| |
| @test_wrapper('Auto Reconnect', devices={'BLE_MOUSE':1}) |
| def le_auto_reconnect(self): |
| """LE reconnection loop by reseting HID and check reconnection""" |
| |
| device = self.devices['BLE_MOUSE'][0] |
| self.auto_reconnect_loop( |
| device=device, |
| loops=3, |
| check_connected_method=self.test_mouse_left_click) |
| |
| # TODO(b/165690676) - Test is disabled for AVL while it stabilizes in flaky |
| # suite. Remove flags once it's in stable suite. |
| @test_wrapper('Power toggle and Connect Loop', devices={'BLE_MOUSE': 1}) |
| def le_power_toggle_connect_loop(self): |
| """Run autoconnect loop and cycle adapter power between runs. |
| The test makes sure the peer can reconnect after an adapter power |
| cycle. |
| """ |
| device = self.devices['BLE_MOUSE'][0] |
| self.auto_reconnect_loop( |
| device=device, |
| loops=3, |
| check_connected_method=self.test_mouse_left_click, |
| restart_adapter=True) |
| |
| |
| @test_wrapper('GATT Client', devices={'BLE_KEYBOARD':1}) |
| def le_gatt_client_attribute_browse_test(self): |
| """Browse the whole tree-structured GATT attributes""" |
| |
| device = self.devices['BLE_KEYBOARD'][0] |
| self.test_discover_device(device.address) |
| time.sleep(self.TEST_SLEEP_SECS) |
| self.test_pairing(device.address, device.pin, trusted=True) |
| self.test_service_resolved(device.address) |
| self.test_gatt_browse(device.address) |
| |
| |
| # TODO (b/165949047) Flaky behavior on MVL/4.4 kernel causes flakiness when |
| # connection is initiated by slave. Skip the test until 2021 uprev |
| @test_wrapper('LE secondary Test', |
| devices={'BLE_KEYBOARD': 1}, |
| skip_models=LAB_VEYRON_MODELS + ['bob']) |
| def le_role_secondary(self): |
| """Tests connection as secondary""" |
| |
| self.verify_controller_capability( |
| required_roles=['peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| self.controller_secondary_role_test(kbd, kbd_test_func) |
| |
| |
| @test_wrapper('LE primary Before secondary Test', |
| devices={'BLE_KEYBOARD':1, 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_primary_before_secondary(self): |
| """Tests connection as primary and then as secondary""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'pre') |
| self.controller_secondary_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @test_wrapper('LE secondary Before primary Test', devices={'BLE_KEYBOARD':1, |
| 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_secondary_before_primary(self): |
| """Tests connection as secondary and then as primary""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'mid') |
| self.controller_secondary_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @test_wrapper('LE Sender Role Test', devices={'BLE_KEYBOARD':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_sender(self): |
| """Tests basic Nearby Sender role""" |
| |
| self.verify_controller_capability( |
| required_roles=['central'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| |
| self.nearby_sender_role_test(kbd, kbd_test_func) |
| |
| |
| @test_wrapper('LE Sender Role Test During HID', |
| devices={'BLE_KEYBOARD':1, 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_sender_during_hid(self): |
| """Tests Nearby Sender role while already connected to HID device""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'pre') |
| self.nearby_sender_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @test_wrapper('LE HID Test During Sender Role', |
| devices={'BLE_KEYBOARD':1, 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_hid_during_sender(self): |
| """Tests HID device while already in Nearby Sender role""" |
| |
| self.verify_controller_capability( |
| required_roles=['central'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'mid') |
| self.nearby_sender_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| # TODO (b/165949047) Flaky behavior on MVL/4.4 kernel causes flakiness when |
| # connection is initiated by slave. Skip the test until 2021 uprev |
| @test_wrapper('LE Receiver Role Test', |
| devices={'BLE_KEYBOARD': 1}, |
| skip_models=LAB_VEYRON_MODELS + ['bob']) |
| def le_role_receiver(self): |
| """Tests basic Nearby Receiver role""" |
| |
| self.verify_controller_capability( |
| required_roles=['peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| |
| self.nearby_receiver_role_test(kbd, kbd_test_func) |
| |
| |
| @test_wrapper('LE Receiver Role Test During HID', |
| devices={'BLE_KEYBOARD':1, 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_receiver_during_hid(self): |
| """Tests Nearby Receiver role while already connected to HID device""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'pre') |
| self.nearby_receiver_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @test_wrapper('LE HID Test During Receiver Adv', |
| devices={ |
| 'BLE_KEYBOARD': 1, |
| 'BLE_MOUSE': 1 |
| }, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_hid_during_receiver_adv(self): |
| """Tests HID device while already in Nearby Receiver role adv state""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'mid') |
| self.nearby_receiver_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @test_wrapper('LE HID Test During Receiver Role', |
| devices={'BLE_KEYBOARD':1, 'BLE_MOUSE':1}, |
| skip_models=LAB_VEYRON_MODELS) |
| def le_role_hid_during_receiver_connection(self): |
| """Tests HID device while already in Nearby Receiver role connection""" |
| |
| self.verify_controller_capability( |
| required_roles=['central-peripheral'], |
| test_type=self.flag) |
| |
| kbd = self.devices['BLE_KEYBOARD'][0] |
| mouse = self.devices['BLE_MOUSE'][0] |
| |
| kbd_test_func = lambda device: self.test_keyboard_input_from_trace( |
| device, 'simple_text') |
| mouse_test_func = self.test_mouse_left_click |
| |
| hid_test_device = (mouse, mouse_test_func, 'end') |
| self.nearby_receiver_role_test( |
| kbd, kbd_test_func, secondary_info=hid_test_device) |
| |
| |
| @batch_wrapper('LE Health') |
| def le_health_batch_run(self, num_iterations=1, test_name=None): |
| """Run the LE 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 interations to run |
| @param test_name: specifc test to run otherwise None to run the |
| whole batch |
| """ |
| self.le_connect_disconnect_loop() |
| self.le_power_toggle_connect_loop() |
| self.le_mouse_reports() |
| self.le_keyboard_reports() |
| self.le_auto_reconnect() |
| self.le_discovery_test() |
| |
| # Controller role tests |
| self.le_role_hid_during_receiver_adv() |
| self.le_role_hid_during_sender() |
| self.le_role_primary_before_secondary() |
| self.le_role_receiver() |
| self.le_role_receiver_during_hid() |
| self.le_role_secondary() |
| self.le_role_sender() |
| self.le_role_sender_during_hid() |
| |
| |
| def run_once(self, |
| host, |
| num_iterations=1, |
| args_dict=None, |
| test_name=None, |
| flag='Quick Health'): |
| """Run the batch of Bluetooth LE 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.le_health_batch_run(num_iterations, test_name) |
| self.quick_test_cleanup() |
