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

"""A Batch of of Bluetooth enterprise policy health tests"""

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

import time

from six.moves import zip

from autotest_lib.client.common_lib import error
from autotest_lib.client.cros.bluetooth.bluetooth_audio_test_data import A2DP
from autotest_lib.server.cros.bluetooth.bluetooth_adapter_quick_tests import (
        BluetoothAdapterQuickTests)
from autotest_lib.server.cros.bluetooth.bluetooth_adapter_audio_tests import (
        BluetoothAdapterAudioTests)
from autotest_lib.server.cros.bluetooth.bluetooth_adapter_hidreports_tests \
        import BluetoothAdapterHIDReportTests

from autotest_lib.server.cros.bluetooth.bluetooth_test_utils import (
        BluetoothPolicy)


class bluetooth_AdapterEPHealth(BluetoothAdapterQuickTests,
                                BluetoothAdapterAudioTests,
                                BluetoothAdapterHIDReportTests):
    """A Batch of Bluetooth enterprise policy health tests."""

    # A delay for disconnection to finish.
    DISCONNECT_SLEEP_SECS = 2

    # 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
    CONNECT_SLEEP_SECS = 1

    test_wrapper = BluetoothAdapterQuickTests.quick_test_test_decorator
    batch_wrapper = BluetoothAdapterQuickTests.quick_test_batch_decorator


    def get_device_verifier(self, device, expected_pass):
        """Helper function to get a proper test method for verifying device
           avalibility depending on its type

        @param device: a peer device
        @param expected_pass: True if the test is expected to pass
        @returns: a test method if the device type can be recongnized,
                  None otherwise.
        """
        if device.device_type == 'KEYBOARD':
            return self.run_keyboard_tests
        elif device.device_type == 'MOUSE':
            return self.test_mouse_left_click
        elif device.device_type == 'BLUETOOTH_AUDIO':
            # If the test is expected to pass, verify the whole audio procedure
            # Otherwise only make sure A2DP is not connected on peer device.
            if expected_pass:
                return lambda device: self.test_a2dp_sinewaves(device, A2DP, 0)
            else:
                return lambda device: self.test_device_a2dp_connected(device)
        else:
            raise error.TestError('Failed to find verifier for device type %s' %
                                  device.device_type)


    def ep_outgoing_connection(self, device, expected_pass):
        """Run outoging connection tests

        @param device: the peer device
        @param expected_pass: True if the test is expected to pass
        """
        self.test_discover_device(device.address)
        time.sleep(self.TEST_SLEEP_SECS)

        self.test_pairing(device.address, device.pin, trusted=True)
        time.sleep(self.CONNECT_SLEEP_SECS)


    def ep_incoming_connection(self, device, expected_pass):
        """Run incoming connection tests

        @param device: the peer device
        @param expected_pass: True if the test is expected to pass
        """
        self.test_discover_device(device.address)
        time.sleep(self.TEST_SLEEP_SECS)

        self.test_pairing(device.address, device.pin, trusted=True)
        time.sleep(self.CONNECT_SLEEP_SECS)

        self.test_disconnection_by_device(device)
        time.sleep(self.DISCONNECT_SLEEP_SECS)

        if expected_pass:
            self.test_connection_by_device(device)
        else:
            # ignore the result of connection by device since bluez could
            # disconnect the device connection if there is no service
            # available
            adapter_address = self.bluetooth_facade.address
            device.ConnectToRemoteAddress(adapter_address)
        time.sleep(self.CONNECT_SLEEP_SECS)


    def ep_auto_reconnection(self, device, expected_pass):
        """Run auto reconnection tests

        @param device: the peer device
        @param expected_pass: True if the test is expected to pass
        """
        self.test_discover_device(device.address)
        time.sleep(self.TEST_SLEEP_SECS)

        self.test_pairing(device.address, device.pin, trusted=True)
        time.sleep(self.CONNECT_SLEEP_SECS)

        device.AdapterPowerOff()
        time.sleep(self.TEST_SLEEP_SECS)
        # device should be connected after power on
        device.AdapterPowerOn()


    def reset_allowlist_and_raise_fail(self, err_msg):
        """Reset the allowlist and raise TestFail.

        @param err_msg: the error message
        """
        self.test_reset_allowlist()
        raise error.TestFail(err_msg)


    def post_test_method(self, device):
        """Run tests to make sure the device is not connected and not paired to
        host

        @param device: the peer device
        """

        self.test_disconnection_by_adapter(device.address)
        self.test_remove_pairing(device.address)

    def run_test_method(self, pre_test_method, devices, uuids='',
                        expected_passes=True):
        """Run specified pre_test_method and verify devices can be used.

        @param pre_test_method: the test method to run before verification
        @param devices: a peer device or a list of peer devices
        @param uuids: the uuids in the allowlist to set.
                If uuids is None, it means not to set Allowlist.
                The default value is '' which means to allow all UUIDs.
        @param expected_passes: a boolean value or a list of boolean value,
                each element is True if the ep_test_method is expected to pass.
                The default value is a single value of True.
        """
        if uuids is not None:
            self.test_check_set_allowlist(uuids, True)

        if type(devices) is not list:
            devices = [devices]

        if type(expected_passes) is not list:
            expected_passes = [expected_passes]

        for device, expected_pass in zip(devices, expected_passes):
            if device.device_type == 'BLUETOOTH_AUDIO':
                self.initialize_bluetooth_audio(device, A2DP)
            pre_test_method(device, expected_pass)

        for device, expected_pass in zip(devices, expected_passes):
            self.check_if_affected_by_policy(device, not expected_pass)
            verifier = self.get_device_verifier(device, expected_pass)
            # Whether the test should pass or fail depends on expected_pass.
            self.expect_test(expected_pass, verifier, device)

        for device in devices:
            self.post_test_method(device)
            if device.device_type == 'BLUETOOTH_AUDIO':
                self.cleanup_bluetooth_audio(device, A2DP)


    @test_wrapper('Set Allowlist with Different UUIDs')
    def ep_check_set_allowlist(self):
        """The Enterprise Policy set valid and invalid allowlists test."""
        # Duplicate valid UUIDs
        self.test_check_set_allowlist('abcd,0xabcd', True)

        # Mix of valid UUID16, UUID32, and UUID128
        self.test_check_set_allowlist(
                '0xabcd,abcd1234,'
                'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', True)

        # Mix of valid UUID16, UUID32, and UUID128 with duplicate UUIUDs
        self.test_check_set_allowlist(
                'abcd,0xabcd,abcd1234,0xabcd1234,'
                'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', True)

        # Single valid classic HID UUID
        self.test_check_set_allowlist(BluetoothPolicy.UUID_HID, True)

        # Empty allowlist
        self.test_check_set_allowlist('', True)

        # Invalid UUID should fail.
        self.test_check_set_allowlist(
                'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffff', False)

        # Invalid UUID should fail.
        self.test_check_set_allowlist('aaaaaaaa-bbbb-cccc-dddd', False)


    @test_wrapper('Outgoing: HID: Service in Allowlist', devices={'KEYBOARD':1})
    def ep_outgoing_hid_service_in_allowlist(self):
        """The test with service in allowlist for outgoing connection."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=BluetoothPolicy.UUID_HID, expected_passes=True)


    @test_wrapper('Outgoing: Audio: Service in Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_outgoing_audio_services_in_allowlist(self):
        """The test with service in allowlist for outgoing connection."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=BluetoothPolicy.ALLOWLIST_AUDIO,
                             expected_passes=True)


    @test_wrapper('Outgoing: HID: Service not in Allowlist',
                  devices={'KEYBOARD':1})
    def ep_outgoing_hid_service_not_in_allowlist(self):
        """The test with service not in allowlist for outgoing connection."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids='0xaabb', expected_passes=False)


    @test_wrapper('Outgoing: Audio: Service not in Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_outgoing_audio_services_not_in_allowlist(self):
        """The test with service not in allowlist for outgoing connection."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_outgoing_connection,
                             device,
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID,
                             expected_passes=False)


    @test_wrapper('Outgoing: HID: Empty Allowlist',
                  devices={'KEYBOARD':1})
    def ep_outgoing_hid_empty_allowlist(self):
        """The test with an empty allowlist for outgoing connection."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids='', expected_passes=True)


    @test_wrapper('Outgoing: Audio: Empty Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_outgoing_audio_empty_allowlist(self):
        """The test with an empty allowlist for outgoing connection."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids='', expected_passes=True)


    @test_wrapper('Incoming: HID: Service in Allowlist',
                  devices={'KEYBOARD':1})
    def ep_incoming_hid_service_in_allowlist(self):
        """Service in allowlist for incoming reconnection from device."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_incoming_connection, device,
                             uuids=BluetoothPolicy.UUID_HID, expected_passes=True)


    @test_wrapper('Incoming: Audio: Service in Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_incoming_audio_service_in_allowlist(self):
        """Service in allowlist for incoming reconnection from device."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_incoming_connection, device,
                             uuids=BluetoothPolicy.ALLOWLIST_AUDIO,
                             expected_passes=True)


    @test_wrapper('Incoming: HID: Service not in Allowlist',
                  devices={'KEYBOARD':1})
    def ep_incoming_hid_service_not_in_allowlist(self):
        """Service not in allowlist for incoming reconnection from device."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_incoming_connection, device,
                             uuids='0xaabb', expected_passes=False)


    @test_wrapper('Incoming: Audio: Service not in Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_incoming_audio_service_not_in_allowlist(self):
        """Service not in allowlist for incoming reconnection from device."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_incoming_connection,
                             device,
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID,
                             expected_passes=False)


    @test_wrapper('Incoming: HID: Service empty Allowlist',
                  devices={'KEYBOARD':1})
    def ep_incoming_hid_service_empty_allowlist(self):
        """The test with an empty allowlist for incoming connection."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_incoming_connection, device,
                             uuids='',
                             expected_passes=True)


    @test_wrapper('Incoming: Audio: Service empty Allowlist',
                  devices={'BLUETOOTH_AUDIO':1})
    def ep_incoming_audio_service_empty_allowlist(self):
        """The test with an empty allowlist for incoming connection."""
        device = self.devices['BLUETOOTH_AUDIO'][0]
        self.run_test_method(self.ep_incoming_connection, device,
                             uuids='',
                             expected_passes=True)


    @test_wrapper('Outgoing: BLE Keyboard: Services in Allowlist',
                  devices={'BLE_KEYBOARD':1})
    def ep_outgoing_ble_hid_services_in_allowlist(self):
        """The test for BLE gatt services in allowlist."""
        device = self.devices['BLE_KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID,
                             expected_passes=True)


    @test_wrapper('Outgoing: BLE Keyboard: Services not in Allowlist',
                  devices={'BLE_KEYBOARD':1})
    def ep_outgoing_ble_hid_services_not_in_allowlist(self):
        """The test for BLE gatt services not in allowlist."""
        device = self.devices['BLE_KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection,
                             device,
                             uuids=BluetoothPolicy.ALLOWLIST_AUDIO,
                             expected_passes=False)


    @test_wrapper('Outgoing: BLE Keyboard: Empty Allowlist',
                  devices={'BLE_KEYBOARD':1})
    def ep_outgoing_ble_hid_empty_allowlist(self):
        """The test for BLE gatt services and an empty allowlist."""
        device = self.devices['BLE_KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids='', expected_passes=True)


    @test_wrapper('Reconnection: BLE Keyboard: Service in Allowlist',
                  devices={'BLE_KEYBOARD':1})
    def ep_reconnection_ble_hid_service_in_allowlist(self):
        """Service in allowlist for auto reconnection from device."""
        device = self.devices['BLE_KEYBOARD'][0]
        self.run_test_method(self.ep_auto_reconnection, device,
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID,
                             expected_passes=True)


    @test_wrapper('Reconnection: BLE Keyboard: Service not in Allowlist',
                  devices={'BLE_KEYBOARD':1})
    def ep_reconnection_ble_hid_service_not_in_allowlist(self):
        """Service in allowlist for auto reconnection from device."""
        device = self.devices['BLE_KEYBOARD'][0]
        self.run_test_method(self.ep_auto_reconnection,
                             device,
                             uuids=BluetoothPolicy.ALLOWLIST_AUDIO,
                             expected_passes=False)


    @test_wrapper('Combo: Set Allowlist and Disconnect', devices={'KEYBOARD':1})
    def ep_combo_set_allowlist_and_disconnect(self):
        """Set a new allowlist and current connection should be terminated."""
        device = self.devices['KEYBOARD'][0]
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=BluetoothPolicy.UUID_HID, expected_passes=True)

        # Setting a non-HID UUID should disconnect the device.
        self.test_check_set_allowlist('abcd', True)
        time.sleep(self.DISCONNECT_SLEEP_SECS)
        self.test_device_is_not_connected(device.address)


    @test_wrapper('Combo: Successive Allowlist', devices={'KEYBOARD':1})
    def ep_combo_successive_allowlists(self):
        """A new allowlist overwrites previoius one and allows connection."""
        device = self.devices['KEYBOARD'][0]

        # Setting a non-HID UUID initially.
        self.test_check_set_allowlist('abcd', True)

        # A subsequent HID UUID should supersede the previous setting.
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=BluetoothPolicy.UUID_HID, expected_passes=True)


    @test_wrapper('Combo: HID Allowlist Persists Adapter Reset',
                  devices={'KEYBOARD':1})
    def ep_combo_hid_persists_adapter_reset(self):
        """The Allowlist with HID UUID should persist adapter reset."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist(BluetoothPolicy.UUID_HID, True)
        self.test_reset_on_adapter()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=True)


    @test_wrapper('Combo: Non-HID Allowlist Persists Adapter Reset',
                  devices={'KEYBOARD':1})
    def ep_combo_non_hid_persists_adapter_reset(self):
        """The Allowlist with non-HID UUID should persist adapter reset."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist('abcd', True)
        self.test_reset_on_adapter()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=False)


    @test_wrapper('Combo: HID Allowlist Persists bluetoothd restart',
                  devices={'KEYBOARD':1})
    def ep_combo_hid_persists_bluetoothd_restart(self):
        """The Allowlist with HID UUID should persist bluetoothd restart."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist(BluetoothPolicy.UUID_HID, True)
        self.test_stop_bluetoothd()
        self.test_start_bluetoothd()
        # Powering on adapter could take a few milliseconds, make sure the power
        # is on before proceeding.
        self.test_adapter_work_state()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=True)


    @test_wrapper('Combo: Non-HID Allowlist Persists bluetoothd restart',
                  devices={'KEYBOARD':1})
    def ep_combo_non_hid_persists_bluetoothd_restart(self):
        """The Allowlist with non-HID UUID should persist bluetoothd restart."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist('abcd', True)
        self.test_stop_bluetoothd()
        self.test_start_bluetoothd()
        # Powering on adapter could take a few milliseconds, make sure the power
        # is on before proceeding.
        self.test_adapter_work_state()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=False)


    @test_wrapper('Combo: HID Allowlist Persists reboot',
                  devices={'KEYBOARD':1})
    def ep_combo_hid_persists_reboot(self):
        """The Allowlist with HID UUID should persist reboot."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist(BluetoothPolicy.UUID_HID, True)
        self.reboot()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=True)


    @test_wrapper('Combo: Non-HID Allowlist Persists reboot',
                  devices={'KEYBOARD':1})
    def ep_combo_non_hid_persists_reboot(self):
        """The Allowlist with non-HID UUID should persist reboot."""
        device = self.devices['KEYBOARD'][0]
        self.test_check_set_allowlist('aaaa', True)
        self.reboot()
        self.run_test_method(self.ep_outgoing_connection, device,
                             uuids=None, expected_passes=False)


    @test_wrapper('MD: BLE HID and Audio: Services in Allowlist',
                  devices={'BLE_MOUSE':1, 'BLUETOOTH_AUDIO':1})
    def ep_md_ble_hid_and_audio_in_allowlist(self):
        """The multi-device test for BLE HID and audio services in allowlist."""
        hid_device = self.devices['BLE_MOUSE'][0]
        audio_device = self.devices['BLUETOOTH_AUDIO'][0]

        self.run_test_method(self.ep_outgoing_connection,
                             [hid_device, audio_device],
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID_AUDIO,
                             expected_passes=[True, True])


    @test_wrapper('MD: BLE HID and Audio: Only Audio in Allowlist',
                  devices={'BLE_MOUSE':1, 'BLUETOOTH_AUDIO':1})
    def ep_md_audio_in_allowlist(self):
        """The multi-device test for audio services in allowlist."""
        hid_device = self.devices['BLE_MOUSE'][0]
        audio_device = self.devices['BLUETOOTH_AUDIO'][0]

        self.run_test_method(self.ep_outgoing_connection,
                             [hid_device, audio_device],
                             uuids=BluetoothPolicy.ALLOWLIST_AUDIO,
                             expected_passes=[False, True])


    @test_wrapper('MD: BLE HID and Audio: Only BLE HID in Allowlist',
                  devices={'BLE_KEYBOARD':1, 'BLUETOOTH_AUDIO':1})
    def ep_md_ble_hid_in_allowlist(self):
        """The multi-device test for audio services in allowlist."""
        hid_device = self.devices['BLE_KEYBOARD'][0]
        audio_device = self.devices['BLUETOOTH_AUDIO'][0]

        self.run_test_method(self.ep_outgoing_connection,
                             [hid_device, audio_device],
                             uuids=BluetoothPolicy.ALLOWLIST_BLE_HID,
                             expected_passes=[True, False])


    @test_wrapper('MD: Classic and BLE HID: Services in Allowlist',
                  devices={'BLE_KEYBOARD':1, 'MOUSE':1})
    def ep_md_hid_and_ble_hid_in_allowlist(self):
        """The multi-device test for Classic and BLE HID in the allowlist."""
        keyboard_device = self.devices['BLE_KEYBOARD'][0]
        mouse_device = self.devices['MOUSE'][0]

        self.run_test_method(self.ep_outgoing_connection,
                             [keyboard_device, mouse_device],
                             uuids=BluetoothPolicy.ALLOWLIST_CLASSIC_BLE_HID,
                             expected_passes=[True, True])


    @test_wrapper('MD: BLE HID and Audio: Empty Allowlist',
                  devices={'BLE_KEYBOARD':1, 'BLUETOOTH_AUDIO':1})
    def ep_md_ble_hid_and_audio_empty_allowlist(self):
        """The multi-device test for BLE HID and Audio with empty allowlist."""
        hid_device = self.devices['BLE_KEYBOARD'][0]
        audio_device = self.devices['BLUETOOTH_AUDIO'][0]

        self.run_test_method(self.ep_outgoing_connection,
                             [hid_device, audio_device],
                             uuids='',
                             expected_passes=[True, True])


    @batch_wrapper('EP Health')
    def ep_health_batch_run(self, num_iterations=1, test_name=None):
        """Run the EP health test batch or a specific given test.

        @param num_iterations: how many iterations to run
        @param test_name: specific test to run otherwise None to run the
                whole batch
        """

        self.ep_check_set_allowlist()

        self.ep_outgoing_hid_service_in_allowlist()
        self.ep_outgoing_hid_service_not_in_allowlist()
        self.ep_outgoing_hid_empty_allowlist()

        self.ep_outgoing_ble_hid_services_in_allowlist()
        self.ep_outgoing_ble_hid_services_not_in_allowlist()
        self.ep_outgoing_ble_hid_empty_allowlist()

        self.ep_incoming_hid_service_in_allowlist()
        self.ep_incoming_hid_service_not_in_allowlist()
        self.ep_incoming_hid_service_empty_allowlist()

        self.ep_outgoing_audio_services_in_allowlist()
        self.ep_outgoing_audio_services_not_in_allowlist()
        self.ep_outgoing_audio_empty_allowlist()

        self.ep_incoming_audio_service_in_allowlist()
        self.ep_incoming_audio_service_not_in_allowlist()
        self.ep_incoming_audio_service_empty_allowlist()

        self.ep_reconnection_ble_hid_service_in_allowlist()
        self.ep_reconnection_ble_hid_service_not_in_allowlist()

        self.ep_combo_set_allowlist_and_disconnect()
        self.ep_combo_successive_allowlists()
        self.ep_combo_hid_persists_adapter_reset()
        self.ep_combo_non_hid_persists_adapter_reset()
        self.ep_combo_hid_persists_bluetoothd_restart()
        self.ep_combo_non_hid_persists_bluetoothd_restart()
        self.ep_combo_hid_persists_reboot()
        self.ep_combo_non_hid_persists_reboot()

        self.ep_md_ble_hid_and_audio_in_allowlist()
        self.ep_md_audio_in_allowlist()
        self.ep_md_ble_hid_in_allowlist()
        self.ep_md_hid_and_ble_hid_in_allowlist()
        self.ep_md_ble_hid_and_audio_empty_allowlist()

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

        @param host: the DUT, usually a chromebook
        @param num_iterations: the number of rounds to execute the test
        @param 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.ep_health_batch_run(num_iterations, test_name)
        self.quick_test_cleanup()