# Lint as: python2, python3
# Copyright 2016 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.

"""Server side bluetooth tests on adapter ble advertising.

The Mnemonics describing the test cases:
    CD: check advertising duration and intervals
    RA: register advertisements
    UA: unregister advertisements
    SI: set advertising intervals
    RS: reset advertising
    FRA: fail to register extra advertisements when max ones
         have been registered.
    FSI: fail to set advertising intervals beyond legitimate range
         of [20 ms, 10,240 ms].
    PC: power cycle the bluetooth adapter (controller).
    SR: suspend and resume the DUT (chromebook)

A test represents a component of a test case which comprises a
sequence of tests. A test case usually requires a tester (user)
to perform a sequence of actions and make a sequence of
observations if the test case is performed manually.

A test consists of an optional action such as "register n
advertisements" and a number of test criteria such as "verifying
if min advertising interval is set to an expected value" or
"verifying if advertising is disabled".

"""

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

import copy
import logging
import re
import time

import common
from autotest_lib.server.cros.bluetooth import advertisements_data
from autotest_lib.server.cros.bluetooth import bluetooth_adapter_tests
from six.moves import range
from six.moves import zip

test_case_log = bluetooth_adapter_tests.test_case_log
test_retry_and_log = bluetooth_adapter_tests.test_retry_and_log

class bluetooth_AdapterLEAdvertising(
        bluetooth_adapter_tests.BluetoothAdapterTests):
    """Server side bluetooth adapter advertising Test.

    This class comprises a number of test cases to verify
    bluetooth low-energy advertising.

    Refer to BluetoothAdapterTests for the implementation of the tests
    performed in this autotest test.

    Refer to the design doc for more details:
    "Test Cases for Bluetooth Low-Energy Advertising".

    """

    # The software advertising rotation is a default bluez parameter, 2 seconds
    SOFTWARE_ROTATION_INTERVAL_S = 2

    # If hardware offloading is available, a 'default' discovery time is used,
    # that will not depend on number of advertisements registered since they are
    # advertised in parallel.
    DEFAULT_DISCOVERY_TIME_S = 3

    @staticmethod
    def get_instance_ids(advertisements):
        """Get the list of instace IDs starting at 1.

        @param advertisements: a list of advertisements.

        """
        return list(range(1, len(advertisements) + 1))


    def register_advertisements(self, advertisements, min_adv_interval_ms,
                                max_adv_interval_ms, instance_ids=None):
        """Register multiple advertisements continuously.

        @param advertisements: a list of advertisement instances.
        @param min_adv_interval_ms: min_adv_interval in milliseconds.
        @param max_adv_interval_ms: max_adv_interval in milliseconds.
        @param instance_ids: the list of instance IDs to register.
        """
        if instance_ids is None:
            instance_ids = self.get_instance_ids(advertisements)

        for instance_id, advertisement in zip(instance_ids, advertisements):
            advertisement['MinInterval'] = min_adv_interval_ms
            advertisement['MaxInterval'] = max_adv_interval_ms

            self.test_register_advertisement(advertisement, instance_id)


    def unregister_advertisements(self, advertisements, instance_ids=None):
        """Register multiple advertisements.

        @param advertisements: a list of advertisement instances.
        @param instance_ids: the list of instance IDs to unregister.

        """
        if instance_ids is None:
            instance_ids = self.get_instance_ids(advertisements)

        count = 0
        number_advs = len(advertisements)
        for instance_id, advertisement in zip(instance_ids, advertisements):
            # Advertising is only disabled at the removal of the
            # last advertisement.
            count += 1
            advertising_disabled = count == number_advs
            self.test_unregister_advertisement(advertisement,
                                               instance_id,
                                               advertising_disabled)


    def check_kernel_version(self):
        """ Check if test can execute on this kernel version."""

        logging.info("Checking kernel version {}".format(self.kernel_version))
        #
        # Due to crbug/729648, we cannot set advertising intervals
        # on kernels that are 3.8.11 and below, so we raise TestNAError.
        # 3.8.12 used so that version of the form 3.8.11<suffix> fails the check
        #
        self.is_supported_kernel_version(self.kernel_version, "3.8.12",
                                         'Test cannnot proceed on old kernels')
        #
        # Due to crbug/946835, some messages does not reach btmon
        # causing our tests to fails. This is seen on kernel 3.18 and lower.
        # Remove this check when the issue is fixed
        # TODO(crbug/946835)
        #
        self.is_supported_kernel_version(self.kernel_version, "3.19",
                                         'Test cannnot proceed on this'
                                         'kernel due to crbug/946835 ')
        logging.debug("Test is supported on this kernel version")


    # ---------------------------------------------------------------
    # Definitions of all test cases
    # ---------------------------------------------------------------

    def _get_uuids_from_advertisement(self, adv, type):
        """Parses Solicit or Service UUIDs from advertising data

        Data to be parsed has the following structure:
        16-bit Service UUIDs (complete): 2 entries
            Heart Rate (0x180d)
            Battery Service (0x180f)

        @param adv: string advertising data as collected by btmon
        @param type: Type of UUIDs to parse, either 'Solicit' or 'Service'

        @returns: list of UUIDs as ints
        """
        if not adv:
            return []

        lines = adv.split('\n')
        num_uuids = 0
        # Find Service UUID section in adv and grab number of entries
        for idx, line in enumerate(lines):
            if '{} UUIDs (complete)'.format(type) in line:
                search_res = re.search('(\d) entr', line)
                if search_res and search_res.group(1):
                    num_uuids = int(search_res.group(1))
                    break

        found_uuids = []
        # Iterate through each entry and collect UUIDs. UUIDs are saved as ints
        # to reduce complexity of comparing hex strings, i.e. ab vs AB vs 0xab
        for lineidx in range(idx+1, idx+num_uuids+1):
            line = lines[lineidx]
            search_res = re.search('\((.*?)\)', line)
            if search_res and search_res.group(1):
                uuid = search_res.group(1)
                found_uuids.append(int(uuid, 16))

        return found_uuids


    def _get_company_data_from_advertisement(self, adv):
        """Parses Company ID and associated company data from advertisement

        Data to be parsed has the following structure:
        Company: not assigned (65281)
            Data: 1a1b1c1d1e

        @param adv: string advertising data as collected by btmon

        @returns: dictionary with structure {company uuid: company data}
        """

        lines = adv.split('\n')

        for idx, line in enumerate(lines):
            if 'Company:' in line:
                search_res = re.search('\((.*?)\)', line)
                if search_res and search_res.group(1):
                    company_id = int(search_res.group(1))
                    break

        # Company data is on the line after the header, and is the last block
        # printed
        if company_id and idx+1 < len(lines):
            company_data = lines[idx+1].split(' ')[-1]
            return {company_id: company_data}

        return {}


    def _get_service_data_from_advertisement(self, adv):
        """Parses Service data from advertisement

        Data to be parsed has the following structure:
        Service Data (UUID 0x9991): 1112131415

        @param adv: string advertising data as collected by btmon

        @returns: dictionary with structure {company uuid: company data}
        """

        lines = adv.split('\n')

        discovered_service_data = {}
        # Iterate through lines in advertisement, grabbing Service Data entries
        for line in lines:
            if 'Service Data' in line:
                search_res = re.search('\(UUID (.*?)\)', line)
                if search_res and search_res.group(1):
                    found_uuid = search_res.group(1)
                    found_data = line.split(' ')[-1]

                    discovered_service_data[int(found_uuid, 16)] = found_data

        return discovered_service_data


    def validate_scan_rsp_reception(self, peer, advertisement, discover_time):
        """Validate our advertisement's scan response is located by the peer

        If our advertisements are configured with scan response data, we wish
        to confirm that a scanning peer will be able to discover this content.

        @param peer: Handle to peer device for advertisement collection
        @param advertisement: Advertisement data that has been enabled on DUT
            side
        @param discover_time: Number of seconds we should spend discovering
            before considering the device undiscoverable

        @returns: True if scan response is discovered and is correct, else False
        """

        scan_rsp_data = advertisement.get('ScanResponseData', {})

        # For now, scan response can only contain service data (ad type 0x16):
        # It appears in a scan response event with the following format:
        # 'Service Data (UUID 0xfef3): 010203...'
        if '0x16' in scan_rsp_data:
            service_uuid_data = scan_rsp_data['0x16']

            # First two bytes of data make up 16 bit service UUID
            uuid = service_uuid_data[1] * 256 + service_uuid_data[0]
            # Subsequent bytes make up the service data
            service_data = ''.join(
                    ['{:02x}'.format(data) for data in service_uuid_data[2:]])

            search_str = 'Service Data (UUID 0x{:4x}): {}'.format(
                    uuid, service_data)
            logging.debug('Searching btmon for content: {}'.format(search_str))

            # Locate a scan response with the above entry. Pass if it is found
            start_time = time.time()
            found_adv = peer.FindAdvertisementWithAttributes(
                    [search_str, 'SCAN_RSP'], discover_time)

            logging.info('Scan response discovered after %fs',
                         time.time() - start_time)

            return bool(found_adv)

        return True

    def _test_peer_received_correct_adv(self, peer, advertisement,
                                        discover_time):
        """Test that configured advertisements are found by peer

        We need to verify quality of advertising service from the perspective of
        the client, as this is externally visible in cases like Nearby features.
        This test ensures advertisements are discovered and are correct,
        helping to confirm quality provided, especially with multi-advertising

        @param peer: Handle to peer device for advertisement collection
        @param advertisement: Advertisement data that has been enabled on DUT
            side
        @param discover_time: Number of seconds we should spend discovering
            before considering the device undiscoverable

        @returns: True if advertisement is discovered and is correct, else False
        """

        self.results = {}

        # We locate the advertisement by searching for the ServiceData
        # attribute we configured.
        data_to_match = list(advertisement['ServiceData'].keys())[0]

        start_time = time.time()
        found_adv = peer.FindAdvertisementWithAttributes([data_to_match],
                                                         discover_time)
        logging.info('Advertisement discovered after %fs',
                     time.time() - start_time)

        if not found_adv:
            self.results['advertisement_found'] = False

        # Check that our service UUIDs match what we expect
        found_service_uuids = self._get_uuids_from_advertisement(
                found_adv, 'Service')

        for UUID in advertisement.get('ServiceUUIDs', []):
            if int(UUID, 16) not in found_service_uuids:
                logging.info('Service id %d not found in %s', int(UUID, 16),
                             str(found_service_uuids))
                self.results['service_ids_found'] = False
                return False

        # Check that our solicit UUIDs match what we expect
        found_solicit_uuids = self._get_uuids_from_advertisement(
                found_adv, 'Solicit')

        for UUID in advertisement.get('SolicitUUIDs', []):
            if int(UUID, 16) not in found_solicit_uuids:
                logging.info('Solicid ID %d not found in %s', int(UUID, 16),
                             str(found_solicit_uuids))
                self.results['solicit_ids_found'] = False
                return False

        # Check that our Manufacturer info is correct
        company_info = self._get_company_data_from_advertisement(found_adv)

        expected_company_info = advertisement.get('ManufacturerData', {})
        for UUID in expected_company_info:
            if int(UUID, 16) not in company_info:
                logging.info('Company ID %d not found in advertisement',
                        int(UUID, 16))
                self.results['manufacturer_uuid_found'] = False
                return False

            expected_data = expected_company_info.get(UUID, None)
            formatted_data = ''.join([format(d, 'x') for d in expected_data])

            if formatted_data != company_info.get(int(UUID, 16)):
                logging.info('Manufacturer data %s didn\'t match expected %s',
                        company_info.get(int(UUID, 16)), formatted_data)
                self.results['manufacturer_data_found'] = False
                return False

        # Check that our service data is correct
        service_data = self._get_service_data_from_advertisement(found_adv)

        expected_service_data = advertisement.get('ServiceData', {})
        for UUID in expected_service_data:
            if int(UUID, 16) not in service_data:
                logging.info('Service UUID %d not found in advertisement',
                             int(UUID, 16))
                self.results['service_data_uuid_found'] = False
                return False

            expected_data = expected_service_data.get(UUID, None)
            formatted_data = ''.join([format(d, 'x') for d in expected_data])

            if formatted_data != service_data.get(int(UUID, 16)):
                logging.info('Service data %s didn\'t match expected %s',
                             service_data.get(int(UUID, 16)), formatted_data)
                self.results['service_data_found'] = False
                return False

        # Validate scan response from peer's perspective
        if not self.validate_scan_rsp_reception(peer, advertisement,
                                                discover_time):
            self.results['scan_rsp_found'] = False
            return False

        return True


    def get_host_discovery_time(self, num_adv):
        """Estimates how long it will take the peer to discover the host

        The amount of time we wait for the peer to discover the host's
        advertisement depends on how many advertisements are registered, and
        whether the host platform is using hardware offloaded multi-advertising
        or software rotation.

        @param num_adv: Number of advertisements that are active
        @returns: number of seconds we should wait for discovery
        """

        if self.ext_adv_enabled():
            return self.DEFAULT_DISCOVERY_TIME_S

        return num_adv * self.SOFTWARE_ROTATION_INTERVAL_S

    @test_retry_and_log(False)
    def test_peer_received_correct_adv(self, peer, advertisement,
                                       discover_time):
        """Tests that advertisement can be received by the peer"""

        return self._test_peer_received_correct_adv(peer, advertisement,
                                                    discover_time)

    @test_retry_and_log(False, messages_start=False, messages_stop=False)
    def test_peer_failed_received_correct_adv(self, peer, advertisement,
                                              discover_time):
        """Tests that advertisement can not be received by the peer"""

        return not self._test_peer_received_correct_adv(
                peer, advertisement, discover_time)

    def advertising_peer_test(self, peer):
        """Verifies that advertisements registered on DUT are seen by peer

        @param peer: handle to peer used in test
        """

        self.kernel_version = self.host.get_kernel_version()
        self.check_kernel_version()

        self.bluetooth_le_facade = self.bluetooth_facade

        # Register some advertisements
        num_adv = 3
        self.test_reset_advertising()

        for i in range(0, num_adv):
            self.bluetooth_le_facade.register_advertisement(
                    advertisements_data.ADVERTISEMENTS[i])

        discover_time = self.get_host_discovery_time(num_adv)

        for i in range(0, num_adv):
            res = self.test_peer_received_correct_adv(
                    peer, advertisements_data.ADVERTISEMENTS[i], discover_time)

    def advertising_peer_suspend_resume_test(self, peer):
        """Verify expected advertising behavior around suspend/resume

        For power and usage sake, we expect that when the system suspends, any
        advertising instances should be paused. When we resume from suspend,
        they should be re-enabled again. To confirm this behavior, the test
        performs the following steps:

        - Register some advertisements
        - Verify that advertisements are discoverable by remote device
        - Enter suspend
        - Verify that advertisements are NOT discoverable by remote device
        - Exit suspend
        - Verify that advertisements are discoverable by remote device

        @param peer: handle to peer used in test
        """

        self.kernel_version = self.host.get_kernel_version()
        self.check_kernel_version()

        self.bluetooth_le_facade = self.bluetooth_facade

        # Register some advertisements
        num_adv = 3
        discover_time = self.get_host_discovery_time(num_adv)
        self.test_reset_advertising()

        for i in range(0, num_adv):
            self.bluetooth_le_facade.register_advertisement(
                    advertisements_data.ADVERTISEMENTS[i])

        # Verify they can all be discovered
        for i in range(0, num_adv):
            res = self.test_peer_received_correct_adv(
                    peer, advertisements_data.ADVERTISEMENTS[i], discover_time)

        # Enter suspend long enough to verify none of the registered
        # advertisements are discoverable. Give a few extra seconds in suspend
        # to be safe
        suspend_time = discover_time * num_adv + 10

        # Trigger suspend, asynchronously trigger wake and wait for resume
        boot_id = self.host.get_boot_id()
        suspend = self.suspend_async(suspend_time=suspend_time)
        start_time = self.bluetooth_facade.get_device_utc_time()
        self.test_suspend_and_wait_for_sleep(suspend, sleep_timeout=5)

        # Verify they can not be discovered
        for i in range(0, num_adv):
            res = self.test_peer_failed_received_correct_adv(
                    peer, advertisements_data.ADVERTISEMENTS[i], discover_time)

        # Wait for device to come out of suspend
        self.test_wait_for_resume(boot_id,
                                  suspend,
                                  resume_timeout=suspend_time,
                                  test_start_time=start_time)

        # Verify reception of advertisements again
        for i in range(0, num_adv):
            res = self.test_peer_received_correct_adv(
                    peer, advertisements_data.ADVERTISEMENTS[i], discover_time)


    @test_case_log
    def test_case_SI200_RA3_CD_UA3(self):
        """Test Case: SI(200) - RA(3) - CD - UA(3)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_SI200_RA3_CD_RA1_CD_UA1_CD_UA3(self):
        """Test Case: SI(200) - RA(3) - CD - RA(1) - CD - UA(1) - CD - UA(3)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        # Make a copy of advertisements since we are going to modify it.
        advertisements = copy.copy(self.three_advertisements)
        number_advs = len(advertisements)
        one_more_advertisement = [self.sixth_advertisement]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Register one more advertisement.
        # The instance ID to register is len(advertisements) + 1 = 4
        self.register_advertisements(one_more_advertisement,
                                     new_min_adv_interval_ms,
                                     new_max_adv_interval_ms,
                                     instance_ids=[number_advs + 1])

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs + 1)

        # Unregister the 3rd advertisement.
        # After removing the advertisement, the remaining instance IDs
        # would be [1, 2, 4]
        instance_id = 3
        self.test_unregister_advertisement(advertisements.pop(instance_id - 1),
                                           instance_id,
                                           advertising_disabled=False)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs)

        # Unregister all existing advertisements which are [1, 2, 4]
        # since adv 3 was removed in the previous step.
        self.unregister_advertisements(advertisements + one_more_advertisement,
                                       instance_ids=[1, 2, 4])


    @test_case_log
    def test_case_SI200_RA3_CD_RS(self):
        """Test Case: SI(200) - RA(3) - CD - RS"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        self.test_reset_advertising(self.get_instance_ids(advertisements))


    @test_case_log
    def test_case_SI200_RA3_CD_UA1_CD_RS(self):
        """Test Case: SI(200) - RA(3) - CD - UA(1) - CD - RS"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        # Make a copy of advertisements since we are going to modify it.
        advertisements = copy.copy(self.three_advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        # Unregister the 1st advertisement.
        # After removing the advertisement, the remaining instance IDs
        # would be [2, 3]
        instance_id = 1
        self.test_unregister_advertisement(advertisements.pop(instance_id - 1),
                                           instance_id,
                                           advertising_disabled=False)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   len(advertisements) - 1)

        self.test_reset_advertising([2, 3])


    @test_case_log
    def test_case_SI200_RA3_CD_UA1_CD_RA2_CD_UA4(self):
        """Test Case: SI(200) - RA(3) - CD - UA(1) - CD - RA(2) - CD - UA(4)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        # Make a copy of three_advertisements since we are going to modify it.
        advertisements1 = copy.copy(self.three_advertisements)
        advertisements2 = self.two_advertisements
        number_advs1 = len(advertisements1)
        number_advs2 = len(advertisements2)

        self.test_reset_advertising()

        self.register_advertisements(advertisements1, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs1)

        # Unregister the 2nd advertisement.
        # After removing the 2nd advertisement, the remaining instance IDs
        # would be [1, 3]
        instance_id = 2
        self.test_unregister_advertisement(advertisements1.pop(instance_id - 1),
                                           instance_id,
                                           advertising_disabled=False)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs1 - 1)

        # Register two more advertisements.
        # The instance IDs to register would be [2, 4]
        self.register_advertisements(advertisements2, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms,
                                     instance_ids=[2, 4])

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs1 + number_advs2 - 1)

        # Unregister all advertisements.
        # The instance_ids of advertisements1 is [1, 3].
        # The instance_ids of advertisements2 is [2, 4].
        self.unregister_advertisements(advertisements1 + advertisements2,
                                       instance_ids=[1, 3, 2, 4])


    @test_case_log
    def test_case_SI200_RA5_CD_FRA1_CD_UA5(self):
        """Test Case: SI(200) - RA(5) - CD - FRA(1) - CD - UA(5)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.five_advertisements
        extra_advertisement = self.sixth_advertisement
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        self.test_fail_to_register_advertisement(extra_advertisement,
                                                 new_min_adv_interval_ms,
                                                 new_max_adv_interval_ms)

        # If the registration fails and extended advertising is available,
        # there will be no events in btmon. Therefore, we only run this part of
        # the test if extended advertising is not available, indicating that
        # software advertisement rotation is being used.
        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs)

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_SI200_RA3_CD_PC_CD_UA3(self):
        """Test Case: SI(200) - RA(3) - CD - PC - CD - UA(3)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        # Turn off and then turn on the adapter.
        self.test_power_off_adapter()
        time.sleep(1)
        self.test_power_on_adapter()

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_SI200_RA3_CD_SR_CD_UA3(self):
        """Test Case: SI(200) - RA(3) - CD - SR - CD - UA(3)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        # Suspend for a while and resume.
        self.suspend_resume()

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA3_CD_SI200_CD_UA3(self):
        """Test Case: RA(3) - CD - SI(200) - CD - UA(3)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA3_CD_SI200_CD_RS(self):
        """Test Case: RA(3) - CD - SI(200) - CD - RS"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        self.test_reset_advertising(self.get_instance_ids(advertisements))


    @test_case_log
    def test_case_RA3_CD_SI200_CD_UA1_CD_RS(self):
        """Test Case: RA(3) - CD - SI(200) - CD - UA(1) - CD - RS"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Unregister the 2nd advertisement.
        instance_id = 2
        self.test_unregister_advertisement(advertisements[instance_id - 1],
                                           instance_id,
                                           advertising_disabled=False)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs - 1)

        # Test if advertising is reset correctly.Only instances [1, 3] are left.
        self.test_reset_advertising([1, 3])


    @test_case_log
    def test_case_RA3_CD_SI200_CD_SI2000_CD_UA3(self):
        """Test Case: RA(3) - CD - SI(200) - CD - SI(2000) - CD - UA(3)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_small_min_adv_interval_ms = 200
        new_small_max_adv_interval_ms = 200
        new_large_min_adv_interval_ms = 2000
        new_large_max_adv_interval_ms = 2000
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements,
                                     new_small_min_adv_interval_ms,
                                     new_small_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_small_min_adv_interval_ms,
                                               new_small_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements,
                                     new_large_min_adv_interval_ms,
                                     new_large_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_large_min_adv_interval_ms,
                                               new_large_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA5_CD_SI200_CD_FRA1_CD_UA5(self):
        """Test Case: RA(5) - CD - SI(200) - CD - FRA(1) - CD - UA(5)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.five_advertisements
        extra_advertisement = self.sixth_advertisement
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        self.test_fail_to_register_advertisement(extra_advertisement,
                                                 new_min_adv_interval_ms,
                                                 new_max_adv_interval_ms)

        # If the registration fails and extended advertising is available,
        # there will be no events in btmon. Therefore, we only run this part of
        # the test if extended advertising is not available, indicating that
        # software advertisement rotation is being used.
        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs)

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA3_CD_SI200_CD_FSI10_CD_FSI20000_CD_UA3(self):
        """Test Case: RA(3) - CD - SI(200) - CD - FSI(10) - CD - FSI(20000) - CD
        - UA(3)
        """
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        invalid_small_min_adv_interval_ms = 10
        invalid_small_max_adv_interval_ms = 10
        invalid_large_min_adv_interval_ms = 20000
        invalid_large_max_adv_interval_ms = 20000
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Fails to set intervals that are too small. Intervals remain the same.
        self.test_fail_to_set_advertising_intervals(
                invalid_small_min_adv_interval_ms,
                invalid_small_max_adv_interval_ms,
                new_min_adv_interval_ms, new_max_adv_interval_ms)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs)

        # Fails to set intervals that are too large. Intervals remain the same.
        self.test_fail_to_set_advertising_intervals(
                invalid_large_min_adv_interval_ms,
                invalid_large_max_adv_interval_ms,
                new_min_adv_interval_ms, new_max_adv_interval_ms)

        if not self.ext_adv_enabled():
            self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                                   new_max_adv_interval_ms,
                                                   number_advs)

        # Unregister all advertisements.
        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA3_CD_SI200_CD_PC_CD_UA3(self):
        """Test Case: RA(3) - CD - SI(200) - CD - PC - CD - UA(3)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Turn off and then turn on the adapter.
        self.test_power_off_adapter()
        time.sleep(1)
        self.test_power_on_adapter()

        # Check if the advertising durations remain the same after resume.
        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Unregister all advertisements.
        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA3_CD_SI200_CD_SR_CD_UA3(self):
        """Test Case: RA(3) - CD - SI(200) - CD - SR - CD - UA(3)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = self.three_advertisements
        number_advs = len(advertisements)

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               number_advs)

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Suspend for a while and resume.
        self.suspend_resume()

        # Check if the advertising durations remain the same after resume.
        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               number_advs)

        # Unregister all advertisements.
        self.unregister_advertisements(advertisements)

    # SINGLE TEST CASES
    @test_case_log
    def test_case_SI200_RA1_CD_UA1(self):
        """Test Case: SI(200) - RA(1) - CD - UA(1)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.sixth_advertisement]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_SI200_RA1_CD_RS(self):
        """Test Case: SI(200) - RA(1) - CD - RS"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.first_advertisement]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.test_reset_advertising()


    @test_case_log
    def test_case_SI200_RA1_CD_SR_CD_UA1(self):
        """Test Case: SI(200) - RA(1) - CD - SR - CD - UA(1)"""
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.sixth_advertisement]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.suspend_resume()

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA1_CD_SI200_CD_UA1(self):
        """Test Case: RA(1) - CD - SI(200) - CD - UA(1)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.first_advertisement]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA1_CD_SI200_CD_RS(self):
        """Test Case: RA(1) - CD - SI(200) - CD - RS"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.sixth_advertisement]
        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))
        self.test_reset_advertising()


    @test_case_log
    def test_case_RA1_CD_SI200_CD_FSI10_UA1_RA1_CD_UA1(self):
        """Test Case:  RA(1) - CD - SI(200) - CD - FSI(10) - UA(1)
         - RA(1) - CD - UA(1)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        invalid_small_min_adv_interval_ms = 10
        invalid_small_max_adv_interval_ms = 10
        advertisements = [self.three_advertisements[1]]
        new_advertisement = [self.three_advertisements[2]]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        # Fails to set intervals that are too small. Intervals remain the same.
        self.test_fail_to_set_advertising_intervals(
                invalid_small_min_adv_interval_ms,
                invalid_small_max_adv_interval_ms,
                new_min_adv_interval_ms, new_max_adv_interval_ms)

        self.unregister_advertisements(advertisements)

        # Register a new advertisement in order to avoid kernel caching.
        self.register_advertisements(new_advertisement, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(new_advertisement)


    @test_case_log
    def test_case_RA1_CD_SI200_CD_FSI20000_UA1_RA1_CD_UA1(self):
        """Test Case:  RA(1) - CD - SI(200) - CD - FSI(20000) - UA(1)
         - RA(1) - CD - UA(1)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        invalid_large_min_adv_interval_ms = 20000
        invalid_large_max_adv_interval_ms = 20000
        advertisements = [self.three_advertisements[1]]
        new_advertisement = [self.three_advertisements[2]]

        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))
        # Fails to set intervals that are too large. Intervals remain the same.
        self.test_fail_to_set_advertising_intervals(
                invalid_large_min_adv_interval_ms,
                invalid_large_max_adv_interval_ms,
                new_min_adv_interval_ms, new_max_adv_interval_ms)

        self.unregister_advertisements(advertisements)

        # Register a new advertisement in order to avoid kernel caching.
        self.register_advertisements(new_advertisement, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(new_advertisement)


    @test_case_log
    def test_case_RA1_CD_SI200_CD_PC_CD_UA1(self):
        """Test Case: RA(1) - CD - SI(200) - CD - PC - CD - UA(1)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.sixth_advertisement]
        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        # Turn off and then turn on the adapter.
        self.test_power_off_adapter()
        time.sleep(1)
        self.test_power_on_adapter()

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)


    @test_case_log
    def test_case_RA1_CD_SI200_CD_SR_CD_UA1(self):
        """Test Case: RA(1) - CD - SI(200) - CD - SR - CD - UA(1)"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        new_min_adv_interval_ms = 200
        new_max_adv_interval_ms = 200
        advertisements = [self.first_advertisement]
        self.test_reset_advertising()

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        self.test_check_duration_and_intervals(orig_min_adv_interval_ms,
                                               orig_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)
        self.register_advertisements(advertisements, new_min_adv_interval_ms,
                                     new_max_adv_interval_ms)

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.suspend_resume()

        self.test_check_duration_and_intervals(new_min_adv_interval_ms,
                                               new_max_adv_interval_ms,
                                               len(advertisements))

        self.unregister_advertisements(advertisements)

    @test_case_log
    def test_case_nearby_mediums_fast(self):
        """Verify minimal test case for nearby sharing"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS

        # We set a specific advertisement with fields required by Nearby
        # sharing service
        advertisements = [advertisements_data.NEARBY_MEDIUMS_FAST_ADV]

        self.test_reset_advertising()

        # Nearby share requires general discoverable advertising flag be set.
        # Bluez sets this flag based on the adapter's Discoverable property,
        # so we apply this setting here
        self.bluetooth_facade.set_discoverable(True)

        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        # Ensure that our discoverable flag is advertised
        self.test_advertising_flags(['Advertise as Discoverable'])

    @test_case_log
    def test_case_adv_before_scan(self):
        """Verify we can scan after advertising starts

        We found that when extended advertising is available, any Set Adv
        Disable HCI command would mark the hdev as not advertising, even if
        other instances were active at the time. Later attempts to start
        discovery would fail, because kernel tries to update the random address
        without knowing to pause the advertisements. This test case replicates
        this failure condition to validate the fix.
        """
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        advertisements = self.three_advertisements

        self.test_reset_advertising()

        # Register several advertisements
        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

        # Unregister one active advertisement.
        instance_id = 2
        self.test_unregister_advertisement(advertisements[instance_id - 1],
                                           instance_id,
                                           advertising_disabled=False)

        self.test_start_discovery()

        # Test if advertising is reset correctly.Only instances [1, 3] are left.
        self.test_reset_advertising([1, 3])

    @test_case_log
    def test_case_broadcast(self):
        """Verify minimal test case for broadcasted advertising"""
        orig_min_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS
        orig_max_adv_interval_ms = self.DEFAULT_MIN_ADVERTISEMENT_INTERVAL_MS

        # We set a specific advertisement that uses the 'broadcast' mode
        advertisements = [advertisements_data.NEARBY_BROADCAST_ADV]

        self.test_reset_advertising()

        # Verify that registration is successful, and that all configured
        # properties are sent to the controller.
        self.register_advertisements(advertisements, orig_min_adv_interval_ms,
                                     orig_max_adv_interval_ms)

    def run_le_advertising_test(self, host, advertisements, test_type, \
                                num_iterations=1):
        """Running Bluetooth adapter LE advertising autotest.

        @param host: device under test host.
        @param advertisements: a list of advertisement instances.
        @param test_type: indicating one of three test types: multi-advertising,
                          single-advertising, reboot (stress only), or
                          suspend_resume (stress only).

        @raises TestNAError: if DUT has low kernel version (<=3.8.11)

        """
        self.host = host
        self.kernel_version = self.host.get_kernel_version()
        self.check_kernel_version()

        self.advertisements = advertisements
        self.first_advertisement = advertisements[0]
        self.two_advertisements = advertisements[3:5]
        self.three_advertisements = advertisements[0:3]
        self.five_advertisements = advertisements[0:5]
        self.sixth_advertisement = advertisements[5]

        self.bluetooth_le_facade = self.bluetooth_facade

        # Reset the adapter to forget previous stored data and turn it on.
        self.test_reset_on_adapter()

        if test_type == 'multi_advertising':
            # Run all test cases for multiple advertisements.
            self.test_case_SI200_RA3_CD_UA3()
            self.test_case_SI200_RA3_CD_RA1_CD_UA1_CD_UA3()
            self.test_case_SI200_RA3_CD_RS()
            self.test_case_SI200_RA3_CD_UA1_CD_RS()
            self.test_case_SI200_RA3_CD_UA1_CD_RA2_CD_UA4()
            # TODO (b/169603469) this test will fail on platforms supporting
            # >5 advertising slots due to new advertising feature, so disable
            # until test can be refactored.
            # self.test_case_SI200_RA5_CD_FRA1_CD_UA5()
            self.test_case_RA3_CD_SI200_CD_UA3()
            self.test_case_RA3_CD_SI200_CD_RS()
            self.test_case_RA3_CD_SI200_CD_UA1_CD_RS()
            self.test_case_RA3_CD_SI200_CD_SI2000_CD_UA3()
            # TODO (b/169603469) this test will fail on platforms supporting
            # >5 advertising slots due to new advertising feature, so disable
            # until test can be refactored.
            # self.test_case_RA5_CD_SI200_CD_FRA1_CD_UA5()
            self.test_case_RA3_CD_SI200_CD_FSI10_CD_FSI20000_CD_UA3()
            self.test_case_SI200_RA3_CD_SR_CD_UA3()
            self.test_case_RA3_CD_SI200_CD_SR_CD_UA3()
            self.test_case_SI200_RA3_CD_PC_CD_UA3()
            self.test_case_RA3_CD_SI200_CD_PC_CD_UA3()

        elif test_type == 'single_advertising':
            # Run all test cases for single advertisement.
            # Note: it is required to change the advertisement instance
            #       so that the advertisement data could be monitored by btmon.
            #       Otherwise, the advertisement data would be just cached and
            #       reused such that the data would not be visible in btmon.
            self.test_case_SI200_RA1_CD_UA1()
            self.test_case_SI200_RA1_CD_RS()
            self.test_case_RA1_CD_SI200_CD_UA1()
            self.test_case_RA1_CD_SI200_CD_RS()
            self.test_case_RA1_CD_SI200_CD_FSI10_UA1_RA1_CD_UA1()
            self.test_case_RA1_CD_SI200_CD_FSI20000_UA1_RA1_CD_UA1()
            self.test_case_SI200_RA1_CD_SR_CD_UA1()
            self.test_case_RA1_CD_SI200_CD_SR_CD_UA1()
            self.test_case_RA1_CD_SI200_CD_PC_CD_UA1()

        elif test_type == 'suspend_resume':
            # Run all test cases for suspend resume stress testing.
            for i in range(num_iterations):
                logging.info('Starting suspend resume loop #%d', i+1)
                self.test_case_SI200_RA3_CD_SR_CD_UA3()
                self.test_case_RA3_CD_SI200_CD_SR_CD_UA3()
                self.test_case_SI200_RA1_CD_SR_CD_UA1()
                self.test_case_RA1_CD_SI200_CD_SR_CD_UA1()

        elif test_type == 'reboot':
            # Run all test cases for reboot stress testing.
            for i in range(num_iterations):
                logging.info('Starting reboot loop #%d', i+1)
                self.test_case_SI200_RA3_CD_PC_CD_UA3()
                self.test_case_RA3_CD_SI200_CD_PC_CD_UA3()
                self.test_case_RA1_CD_SI200_CD_PC_CD_UA1()

        elif test_type == 'nearby':
            self.test_case_nearby_mediums_fast()
            self.test_case_adv_before_scan()

        elif test_type == 'broadcast':
            self.test_case_broadcast()