# Lint as: python2, python3
# Copyright 2019 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""A Batch of Bluetooth stand alone health tests"""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import logging

from autotest_lib.server.cros.bluetooth.bluetooth_adapter_quick_tests import (
        BluetoothAdapterQuickTests)
from autotest_lib.server.cros.bluetooth import bluetooth_dbus_api_tests
from autotest_lib.server.cros.bluetooth import bluetooth_default_state_test
from autotest_lib.server.cros.bluetooth import bluetooth_valid_address_test
from six.moves import range


class bluetooth_AdapterSAHealth(BluetoothAdapterQuickTests,
        bluetooth_default_state_test.bluetooth_Health_DefaultStateTest,
        bluetooth_valid_address_test.bluetooth_Health_ValidAddressTest,
        bluetooth_dbus_api_tests.BluetoothDBusAPITests):

    """A Batch of Bluetooth stand alone health tests. This test is written as
       a batch of tests in order to reduce test time, since auto-test ramp up
       time is costy. 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('Stand Alone basic test', supports_floss=True)
    def sa_basic_test(self):
        """Set of basic stand alone test"""

        # The bluetoothd must be running in the beginning.
        self.test_bluetoothd_running()

        # It is possible that the adapter is not powered on yet.
        # Power it on anyway and verify that it is actually powered on.
        self.test_power_on_adapter()

        # Verify that the adapter could be powered off and powered on,
        # and that it is in the correct working state.
        self.test_power_off_adapter()
        self.test_power_on_adapter()
        self.test_adapter_work_state()

        # Verify that the bluetoothd could be simply stopped and then
        # be started again, and that it is in the correct working state.
        self.test_stop_bluetoothd()
        self.test_start_bluetoothd()
        self.test_adapter_work_state()

        # Verify that the adapter could be reset off and on which includes
        # removing all cached information.
        self.test_reset_off_adapter()
        self.test_reset_on_adapter()
        self.test_adapter_work_state()

        # Verify that the adapter supports basic profiles.
        self.test_UUIDs()

        # Verify that the adapter could start and stop discovery.
        self.test_start_discovery()
        self.test_stop_discovery()
        self.test_start_discovery()

        # Verify that the adapter could set both discoverable and
        # non-discoverable successfully.
        self.test_discoverable()
        self.test_nondiscoverable()
        self.test_discoverable()

        # Verify that the adapter could set pairable and non-pairable.
        self.test_pairable()
        self.test_nonpairable()
        self.test_pairable()

    @test_wrapper('Stand Alone power reset test', supports_floss=True)
    def sa_power_reset(self):
        """Adapter power reset test

        Repeatedly reset adapter power to expect that bluetoothd is running.
        Note that the test takes about 2 minutes to complete and is suitable
        to run in function verification test suite.
        """
        for _ in range(20):
            self.test_reset_on_adapter()
            self.test_bluetoothd_running()


    @test_wrapper('Adapter suspend resume test',
                  supports_floss=True)
    def sa_adapter_suspend_resume_test(self):
        """Test dapter power states is perserved through suspend resume."""
        def adapter_on_SR_test():
            """Test Case: Power on - SR"""
            self.test_power_on_adapter()
            self.test_bluetoothd_running()
            self.suspend_resume()
            self.test_bluetoothd_running()
            self.test_adapter_work_state()
            self.test_power_on_adapter()


        def adapter_off_SR_test():
            """Test Case: Power off - SR"""
            self.test_power_off_adapter()
            self.test_bluetoothd_running()
            self.suspend_resume()
            self.test_power_off_adapter()
            self.test_bluetoothd_running()

        adapter_on_SR_test()
        adapter_off_SR_test()


    @test_wrapper('Adapter present test', supports_floss=True)
    def sa_adapter_present_test(self):
        """Verify that the client has a Bluetooth adapter."""

        # Reset the adapter (if any) to the powered off state.
        self.test_reset_off_adapter()

        # Verify that there is an adapter. This will only return True if both
        # the kernel and bluetooth daemon see the adapter.
        self.test_has_adapter()

    @test_wrapper('Adapter reboot test', supports_floss=True)
    def sa_adapter_reboot_test(self):
        """Verify that adapter power setting persist over reboot

        Test whether power setting persist after a reboot and whether
        adapter can be turned on after reboot
        """

        def test_case_adapter_on_reboot():
            """Test Case: Power on - reboot"""
            self.test_power_on_adapter()
            self.test_bluetoothd_running()
            self.reboot()
            self.test_bluetoothd_running()
            self.test_adapter_work_state()

        def test_case_adapter_off_reboot():
            """Test Case: Power on - reboot"""
            self.test_power_off_adapter()
            self.test_bluetoothd_running()
            self.reboot()
            self.test_has_adapter()
            self.test_is_powered_off()
            self.test_power_on_adapter()
            self.test_bluetoothd_running()

        NUM_ITERATIONS = 3
        for i in range(NUM_ITERATIONS):
            logging.debug('Starting reboot test loop number #%d', i)
            test_case_adapter_on_reboot()
            test_case_adapter_off_reboot()


    @test_wrapper('Adapter DiscoverableTimeout test', supports_floss=True)
    def sa_adapter_discoverable_timeout_test(self):
        """Verify that DiscoverableTimout Property works."""
        result = self.test_discoverable_timeout(timeout_values=[0, 7, 15])
        logging.info("Result is %s", result)

    @test_wrapper('Adapter PairableTimeout test',
                  supports_floss=False)
    def sa_adapter_pairable_timeout_test(self):
        """Verify that PairableTimout Property works."""
        result = self.test_pairable_timeout(timeout_values=[0, 7, 15])
        logging.info("Result is %s", result)

    @test_wrapper('Default state test', supports_floss=True)
    def sa_default_state_test(self):
        """Verify that the Bluetooth adapter has correct state."""
        self.default_state_test()


    @test_wrapper('Valid address test', supports_floss=True)
    def sa_valid_address_test(self):
        """Verify that the client Bluetooth adapter has a valid address."""
        self.valid_address_test()


    @test_wrapper('Valid adapter ID test', supports_floss=True)
    def sa_valid_id_test(self):
        """Verify that the adapter has a correctly-formatted ID"""
        self.test_check_valid_adapter_id()


    @test_wrapper('Valid adapter alias test', supports_floss=True)
    def sa_valid_alias_test(self):
        """Verify that the adapter has a correctly-formatted alias"""
        self.test_check_valid_alias()

    @test_wrapper('DBUS API tests', supports_floss=True)
    def sa_dbus_api_tests(self):
        """ Verify that the Bluetooth DBus API calls work."""
        self.test_dbus_start_discovery_success()
        if not self.floss:
            self.test_dbus_start_discovery_fail_discovery_in_progress()
        self.test_dbus_start_discovery_fail_power_off()
        self.test_dbus_stop_discovery_success()
        self.test_dbus_stop_discovery_fail_discovery_not_in_progress()
        self.test_dbus_stop_discovery_fail_power_off()
        self.test_dbus_get_supported_capabilities_success()
        self.test_dbus_get_supported_capabilities_success_power_off()

    @test_wrapper('EIR Max Alias Size test', supports_floss=True)
    def sa_eir_max_name_size_test(self):
        """ Verify that the non-default max eir name size is used """
        EIR_80_char_name = ('1234567890123456789012345678901234567890'
                            '1234567890123456789012345678901234567890')

        self.test_set_adapter_alias(EIR_80_char_name)


    @batch_wrapper('Stand Alone Health')
    def sa_health_batch_run(self, num_iterations=1, test_name=None):
        """Run the stand alone 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.sa_basic_test()
        self.sa_adapter_suspend_resume_test()
        self.sa_adapter_present_test()
        # self.sa_adapter_reboot_test() disabled since the test is not stable
        self.sa_adapter_discoverable_timeout_test()
        self.sa_default_state_test()
        self.sa_valid_address_test()
        self.sa_dbus_api_tests()
        self.sa_power_reset()
        self.sa_valid_alias_test()


    def run_once(self,
                 host,
                 num_iterations=1,
                 args_dict=None,
                 test_name=None,
                 flag='Quick Health',
                 floss=False):
        """Run the batch of Bluetooth stand health tests

        @param host: the DUT, usually a chromebook
        @param num_iterations: the number of rounds to execute the test
        """
        # BlueZ's alias is set by Chrome, so we need to enable chrome in
        # the single test or batch test.
        need_chrome = not floss and test_name in ["sa_valid_alias_test", None]
        # Initialize and run the test batch or the requested specific test
        self.quick_test_init(host,
                             use_btpeer=False,
                             flag=flag,
                             start_browser=need_chrome,
                             floss=floss,
                             enable_ui=need_chrome)
        self.sa_health_batch_run(num_iterations, test_name)
        self.quick_test_cleanup()