# Lint as: python2, python3
# 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 Classic health tests"""


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
from autotest_lib.server.cros.bluetooth.bluetooth_sdp_tests import \
     BluetoothSDPTests


class bluetooth_AdapterCLHealth(BluetoothAdapterQuickTests,
        BluetoothAdapterPairingTests,
        BluetoothAdapterHIDReportTests,
        BluetoothSDPTests):
    """A Batch of Bluetooth Classic 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={"MOUSE":1})
    def cl_adapter_discovery_test(self):
        """Performs pairing test with mouse peripheral"""
        device = self.devices['MOUSE'][0]

        self.test_discover_device(device.address)
        self.test_device_name(device.address, device.name)


    @test_wrapper('Discoverable Test', devices={"MOUSE":1})
    def cl_adapter_discoverable_test(self):
        """Verifies that DUT can become discoverable and be discovered"""

        device = self.devices['MOUSE'][0]

        # Put DUT into discoverable state
        self.test_discoverable()

        # Try and discover DUT from peripheral device
        self.test_discover_by_device(device)


    @test_wrapper('Pairing Test', devices={"MOUSE":1})
    def cl_adapter_pairing_test(self):
        """Performs pairing test with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.pairing_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click)


    @test_wrapper('keyboard Pairing Test', devices={"KEYBOARD":1})
    def cl_adapter_keyboard_pairing_test(self):
        """Performs pairing test with keyboard peripheral"""
        device = self.devices['KEYBOARD'][0]
        self.pairing_test(device,
                          check_connected_method=\
                          self.run_keyboard_tests)


    @test_wrapper('Pairing Suspend Resume Test', devices={"MOUSE": 1})
    def cl_adapter_pairing_suspend_resume_test(self):
        """Performs pairing test over resume with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.pairing_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click,
                          suspend_resume=True)


    @test_wrapper('Pairing Twice Test', devices={"MOUSE":1})
    def cl_adapter_pairing_twice_test(self):
        """Performs pairing twice test with  mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.pairing_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click,
                          pairing_twice=True)


    @test_wrapper('HID Reports Test', devices={"MOUSE":1})
    def cl_HID_reports_test(self):
        """Performs HID report test with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.run_hid_reports_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click)


    @test_wrapper('HID keyboard Reports Test', devices={'KEYBOARD':1})
    def cl_HID_keyboard_reports_test(self):
        """Performs HID report test with keyboard peripheral"""
        device = self.devices['KEYBOARD'][0]
        self.run_hid_reports_test(device,
                          check_connected_method=\
                          self.run_keyboard_tests)


    @test_wrapper('HID Reconnect Speed Test',
                  devices={"MOUSE": 1},
                  flags=['Quick Health'])
    def cl_HID_reconnect_speed_test(self):
        """Performs HID reconnect speed test with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.hid_reconnect_speed(device=device, device_type='MOUSE')


    @test_wrapper('HID Reports Suspend Resume Test', devices={"MOUSE": 1})
    def cl_HID_reports_suspend_resume_test(self):
        """Performs HID report test over resume with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.run_hid_reports_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click, suspend_resume=True)


    @test_wrapper('HID Reports Reboot Test', devices={"MOUSE":1})
    def cl_HID_reports_reboot_test(self):
        """Performs HID report test over reboot with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.run_hid_reports_test(device,
                          check_connected_method=\
                          self.test_mouse_right_click, reboot=True)


    @test_wrapper('HID Reports Restart Test',
                  devices={"MOUSE": 1},
                  flags=['Quick Health'])
    def cl_HID_reports_restart_test(self):
        """Performs HID report test over bluetoothd restart with mouse
           peripheral
        """
        device = self.devices['MOUSE'][0]
        self.run_hid_reports_test(
                device,
                check_connected_method=self.test_mouse_move_in_xy,
                restart=True)


    @test_wrapper('Connect Disconnect by Device Loop Test',
                  devices={"MOUSE": 1},
                  flags=['Quick Health'])
    def cl_connect_disconnect_by_device_loop_test(self):
        """Performs connect/disconnect by device test with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.connect_disconnect_by_device_loop(
                device=device,
                loops=3,
                device_type='MOUSE',
                check_connected_method=self.test_mouse_move_in_xy)


    @test_wrapper('Connect Disconnect Loop Test', devices={"MOUSE":1})
    def cl_connect_disconnect_loop_test(self):
        """Performs connect/disconnect test with mouse peripheral"""
        device = self.devices['MOUSE'][0]
        self.connect_disconnect_loop(device=device, loops=3)


    @test_wrapper('Page scan during Inquiry', devices={"MOUSE": 1})
    def cl_page_scan_during_inquiry(self):
        """Checks page scan is working during inquiry.

        Scan and pair peer device.
        Start inquiry.
        Disconnect peer device from DUT.
        Reconnect peer device by initiating connection from peer.
        """
        device = self.devices['MOUSE'][0]

        # Setup
        self.assert_discover_and_pair(device)
        self.test_start_discovery()

        # Disconnection should set up page scan so a reconnect immediately
        # afterwards should always succeed
        self.test_disconnection_by_adapter(device.address)
        self.test_connection_by_device(device)

        # Cleanup
        self.test_stop_discovery()

    @test_wrapper('SDP Service Browse Test', devices={"BLUETOOTH_TESTER":1})
    def cl_sdp_service_browse_test(self):
        """Performs sdp browse with tester peripheral"""
        device = self.devices['BLUETOOTH_TESTER'][0]
        self.sdp_service_browse_test(device=device)


    @test_wrapper('SDP Service Attribute Request Test', \
                  devices={"BLUETOOTH_TESTER":1})
    def cl_sdp_service_attribute_request_test(self):
        """Performs sdp browse with tester peripheral"""
        device = self.devices['BLUETOOTH_TESTER'][0]
        self.sdp_service_attribute_request_test(device=device)


    @test_wrapper('SDP Service Search Attribute Request Test', \
                  devices={"BLUETOOTH_TESTER":1})
    def cl_sdp_service_search_attribute_request_test(self):
        """Performs sdp browse with tester peripheral"""
        device = self.devices['BLUETOOTH_TESTER'][0]
        self.sdp_service_search_attribute_request_test(device=device)


    @test_wrapper('SDP Service Search Request Basic Test', \
                  devices={"BLUETOOTH_TESTER":1})
    def cl_sdp_service_search_request_basic_test(self):
        """Performs sdp browse with tester peripheral"""
        device = self.devices['BLUETOOTH_TESTER'][0]
        self.sdp_service_search_request_basic_test(device=device)


    @batch_wrapper('Classic Health')
    def cl_health_batch_run(self, num_iterations=1, test_name=None):
        """Run the Classic 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.cl_HID_keyboard_reports_test()
        self.cl_HID_reports_reboot_test()
        self.cl_HID_reports_restart_test()
        self.cl_HID_reports_suspend_resume_test()
        self.cl_HID_reports_test()
        self.cl_adapter_discoverable_test()
        self.cl_adapter_discovery_test()
        self.cl_adapter_keyboard_pairing_test()
        self.cl_adapter_pairing_suspend_resume_test()
        self.cl_adapter_pairing_test()
        self.cl_adapter_pairing_twice_test()
        self.cl_connect_disconnect_by_device_loop_test()
        self.cl_connect_disconnect_loop_test()
        self.cl_sdp_service_attribute_request_test()
        self.cl_sdp_service_browse_test()
        self.cl_sdp_service_search_attribute_request_test()
        self.cl_sdp_service_search_request_basic_test()


    def run_once(self,
                 host,
                 num_iterations=1,
                 args_dict=None,
                 test_name=None,
                 flag='Quick Health'):
        """Run the batch of Bluetooth Classic 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.cl_health_batch_run(num_iterations, test_name)
        self.quick_test_cleanup()