// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/arc/bluetooth/arc_bluetooth_bridge.h"

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/functional/bind.h"
#include "base/run_loop.h"
#include "base/system/sys_info.h"
#include "base/test/bind.h"
#include "base/test/scoped_chromeos_version_info.h"
#include "base/test/task_environment.h"
#include "chrome/browser/ash/arc/bluetooth/arc_bluez_bridge.h"
#include "chromeos/ash/experiences/arc/bluetooth/bluetooth_type_converters.h"
#include "chromeos/ash/experiences/arc/mojom/bluetooth.mojom.h"
#include "chromeos/ash/experiences/arc/session/arc_bridge_service.h"
#include "chromeos/ash/experiences/arc/test/connection_holder_util.h"
#include "chromeos/ash/experiences/arc/test/fake_bluetooth_instance.h"
#include "device/bluetooth/bluetooth_discovery_session.h"
#include "device/bluetooth/dbus/bluez_dbus_manager.h"
#include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
#include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
#include "device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.h"
#include "device/bluetooth/dbus/fake_bluetooth_gatt_descriptor_client.h"
#include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
#include "device/bluetooth/dbus/fake_bluetooth_le_advertising_manager_client.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {
constexpr int16_t kTestRssi = -50;
constexpr int16_t kTestRssi2 = -70;
constexpr char kTestServiceUUID[] = "00001357-0000-1000-8000-00805f9b34fb";
const std::vector<uint8_t> kEIR = {0x00, 0x01, 0x02};
}  // namespace

namespace arc {

constexpr int kFailureAdvHandle = -1;

// This unittest defaults to testing BlueZ. For Floss, use |ArcFlossBridgeTest|.
class ArcBluetoothBridgeTest : public testing::Test {
 protected:
  void StartDiscovery() {
    base::RunLoop run_loop;
    adapter_->StartDiscoverySession(
        /*client_name=*/std::string(),
        base::BindLambdaForTesting(
            [this, &run_loop](std::unique_ptr<device::BluetoothDiscoverySession>
                                  discovery_session) {
              arc_bluetooth_bridge_->discovery_session_ =
                  std::move(discovery_session);
              run_loop.Quit();
            }),
        base::DoNothing());
    run_loop.Run();
  }

  void AddTestDevice() {
    bluez::BluezDBusManager* dbus_manager = bluez::BluezDBusManager::Get();
    auto* fake_bluetooth_device_client =
        static_cast<bluez::FakeBluetoothDeviceClient*>(
            dbus_manager->GetBluetoothDeviceClient());
    auto* fake_bluetooth_gatt_service_client =
        static_cast<bluez::FakeBluetoothGattServiceClient*>(
            dbus_manager->GetBluetoothGattServiceClient());
    auto* fake_bluetooth_gatt_characteristic_client =
        static_cast<bluez::FakeBluetoothGattCharacteristicClient*>(
            dbus_manager->GetBluetoothGattCharacteristicClient());

    fake_bluetooth_device_client->CreateDevice(
        dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
    fake_bluetooth_device_client->UpdateServiceAndManufacturerData(
        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath),
        {kTestServiceUUID}, /* service_data = */ {},
        /* manufacture_data = */ {});
    fake_bluetooth_device_client->UpdateEIR(
        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath),
        kEIR);
    fake_bluetooth_gatt_service_client->ExposeHeartRateService(
        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
    fake_bluetooth_gatt_characteristic_client->ExposeHeartRateCharacteristics(
        fake_bluetooth_gatt_service_client->GetHeartRateServicePath());

    ChangeTestDeviceRssi(kTestRssi);
  }

  void ChangeTestDeviceRssi(uint16_t rssi) {
    bluez::BluezDBusManager* dbus_manager = bluez::BluezDBusManager::Get();
    auto* fake_bluetooth_device_client =
        static_cast<bluez::FakeBluetoothDeviceClient*>(
            dbus_manager->GetBluetoothDeviceClient());
    fake_bluetooth_device_client->UpdateDeviceRSSI(
        dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath),
        rssi);
  }

  void ChangeTestDeviceConnected(bool connected) {
    bluez::BluezDBusManager* dbus_manager = bluez::BluezDBusManager::Get();
    auto* fake_bluetooth_device_client =
        static_cast<bluez::FakeBluetoothDeviceClient*>(
            dbus_manager->GetBluetoothDeviceClient());
    bluez::FakeBluetoothDeviceClient::Properties* properties =
        fake_bluetooth_device_client->GetProperties(
            dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
    properties->connected.ReplaceValue(connected);
  }

  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter) {
    adapter_ = adapter;
    get_adapter_run_loop_.Quit();
  }

  void SetUp() override {
    std::unique_ptr<bluez::BluezDBusManagerSetter> dbus_setter =
        bluez::BluezDBusManager::GetSetterForTesting();
    auto fake_bluetooth_device_client =
        std::make_unique<bluez::FakeBluetoothDeviceClient>();
    fake_bluetooth_device_client->RemoveAllDevices();
    dbus_setter->SetBluetoothDeviceClient(
        std::move(fake_bluetooth_device_client));
    auto fake_bluetooth_adapter_client =
        std::make_unique<bluez::FakeBluetoothAdapterClient>();
    fake_bluetooth_adapter_client->SetDiscoverySimulation(false);
    fake_bluetooth_adapter_client->SetSimulationIntervalMs(0);
    dbus_setter->SetBluetoothAdapterClient(
        std::move(fake_bluetooth_adapter_client));
    dbus_setter->SetBluetoothGattServiceClient(
        std::make_unique<bluez::FakeBluetoothGattServiceClient>());
    dbus_setter->SetBluetoothGattCharacteristicClient(
        std::make_unique<bluez::FakeBluetoothGattCharacteristicClient>());
    dbus_setter->SetBluetoothGattDescriptorClient(
        std::make_unique<bluez::FakeBluetoothGattDescriptorClient>());

    arc_bridge_service_ = std::make_unique<ArcBridgeService>();
    // TODO(hidehiko): Use Singleton instance tied to BrowserContext.
    arc_bluetooth_bridge_ =
        std::make_unique<ArcBluezBridge>(nullptr, arc_bridge_service_.get());
    fake_bluetooth_instance_ = std::make_unique<FakeBluetoothInstance>();
    arc_bridge_service_->bluetooth()->SetInstance(
        fake_bluetooth_instance_.get(), 20);
    WaitForInstanceReady(arc_bridge_service_->bluetooth());

    device::BluetoothAdapterFactory::Get()->GetAdapter(base::BindOnce(
        &ArcBluetoothBridgeTest::OnAdapterInitialized, base::Unretained(this)));
    // We will quit the loop once we get the adapter.
    get_adapter_run_loop_.Run();
  }

  void TearDown() override {
    arc_bridge_service_->bluetooth()->CloseInstance(
        fake_bluetooth_instance_.get());
    fake_bluetooth_instance_.reset();
    arc_bluetooth_bridge_.reset();
    arc_bridge_service_.reset();
  }

  // Helper methods for multi advertisement tests.
  int32_t ReserveAdvertisementHandle() {
    constexpr int kSentinelHandle = -2;
    last_adv_handle_ = kSentinelHandle;
    arc_bluetooth_bridge_->ReserveAdvertisementHandle(base::BindOnce(
        &ArcBluetoothBridgeTest::ReserveAdvertisementHandleCallback,
        base::Unretained(this)));

    base::RunLoop().RunUntilIdle();
    // Make sure the callback was called.
    EXPECT_NE(kSentinelHandle, last_adv_handle_);
    return last_adv_handle_;
  }

  mojom::BluetoothGattStatus EnableAdvertisement(
      int adv_handle,
      std::unique_ptr<device::BluetoothAdvertisement::Data> data) {
    last_status_ = mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED;
    arc_bluetooth_bridge_->EnableAdvertisement(
        adv_handle, std::move(data),
        base::BindOnce(&ArcBluetoothBridgeTest::StatusSetterCallback,
                       base::Unretained(this)));

    base::RunLoop().RunUntilIdle();
    EXPECT_NE(mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED,
              last_status_);
    return last_status_;
  }

  mojom::BluetoothGattStatus DisableAdvertisement(int adv_handle) {
    last_status_ = mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED;
    arc_bluetooth_bridge_->DisableAdvertisement(
        adv_handle,
        base::BindOnce(&ArcBluetoothBridgeTest::StatusSetterCallback,
                       base::Unretained(this)));

    base::RunLoop().RunUntilIdle();
    EXPECT_NE(mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED,
              last_status_);
    return last_status_;
  }

  mojom::BluetoothGattStatus ReleaseAdvertisementHandle(int adv_handle) {
    last_status_ = mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED;
    arc_bluetooth_bridge_->ReleaseAdvertisementHandle(
        adv_handle,
        base::BindOnce(&ArcBluetoothBridgeTest::StatusSetterCallback,
                       base::Unretained(this)));

    base::RunLoop().RunUntilIdle();
    EXPECT_NE(mojom::BluetoothGattStatus::GATT_REQUEST_NOT_SUPPORTED,
              last_status_);
    return last_status_;
  }

  void ReserveAdvertisementHandleCallback(mojom::BluetoothGattStatus status,
                                          int32_t adv_handle) {
    if (status == mojom::BluetoothGattStatus::GATT_FAILURE)
      last_adv_handle_ = kFailureAdvHandle;
    else
      last_adv_handle_ = adv_handle;
  }

  void StatusSetterCallback(mojom::BluetoothGattStatus status) {
    last_status_ = status;
  }

  int NumActiveAdvertisements() {
    bluez::FakeBluetoothLEAdvertisingManagerClient* adv_client =
        static_cast<bluez::FakeBluetoothLEAdvertisingManagerClient*>(
            bluez::BluezDBusManager::Get()
                ->GetBluetoothLEAdvertisingManagerClient());
    return adv_client->currently_registered();
  }

  int last_adv_handle_;
  mojom::BluetoothGattStatus last_status_;

  std::unique_ptr<ArcBridgeService> arc_bridge_service_;
  std::unique_ptr<FakeBluetoothInstance> fake_bluetooth_instance_;
  std::unique_ptr<ArcBluetoothBridge> arc_bluetooth_bridge_;
  scoped_refptr<device::BluetoothAdapter> adapter_;
  base::test::SingleThreadTaskEnvironment task_environment_;
  base::RunLoop get_adapter_run_loop_;
};

// When we add device to bluez::FakeBluetoothDeviceClient, ArcBluetoothBridge
// should send new device data to Android. This test will then check
// the correctness of the device properties sent via arc bridge.
TEST_F(ArcBluetoothBridgeTest, DeviceFound) {
  EXPECT_EQ(0u, fake_bluetooth_instance_->device_found_data().size());
  EXPECT_EQ(0u,
            fake_bluetooth_instance_->device_properties_changed_data().size());
  StartDiscovery();
  AddTestDevice();
  // Only the first one should invoke a device_found callback. The following
  // device change events should invode the remote_device_properties callback.
  EXPECT_EQ(1u, fake_bluetooth_instance_->device_found_data().size());
  EXPECT_EQ(4u,
            fake_bluetooth_instance_->device_properties_changed_data().size());
  const std::vector<mojom::BluetoothPropertyPtr>& prop =
      fake_bluetooth_instance_->device_properties_changed_data().back();

  EXPECT_EQ(7u, prop.size());
  EXPECT_TRUE(prop[0]->is_bdname());
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyName),
            prop[0]->get_bdname());
  EXPECT_TRUE(prop[1]->is_bdaddr());
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            prop[1]->get_bdaddr()->To<std::string>());
  EXPECT_TRUE(prop[2]->is_uuids());
  EXPECT_THAT(
      prop[2]->get_uuids(),
      testing::UnorderedElementsAre(
          device::BluetoothUUID(
              bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
          device::BluetoothUUID(kTestServiceUUID)));
  EXPECT_TRUE(prop[3]->is_device_class());
  EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyClass,
            prop[3]->get_device_class());
  EXPECT_TRUE(prop[4]->is_device_type());
  // bluez::FakeBluetoothDeviceClient does not return proper device type.
  EXPECT_TRUE(prop[5]->is_remote_friendly_name());
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyName),
            prop[5]->get_remote_friendly_name());
  EXPECT_TRUE(prop[6]->is_remote_rssi());
  EXPECT_EQ(kTestRssi, prop[6]->get_remote_rssi());

  ChangeTestDeviceRssi(kTestRssi2);
  EXPECT_EQ(1u, fake_bluetooth_instance_->device_found_data().size());
  EXPECT_EQ(5u,
            fake_bluetooth_instance_->device_properties_changed_data().size());
  const std::vector<mojom::BluetoothPropertyPtr>& prop2 =
      fake_bluetooth_instance_->device_properties_changed_data().back();
  EXPECT_EQ(7u, prop2.size());
  EXPECT_TRUE(prop2[6]->is_remote_rssi());
  EXPECT_EQ(kTestRssi2, prop2[6]->get_remote_rssi());
}

// Invoke OnDiscoveryStarted to send cached device to BT instance,
// and check correctness of the Advertising data sent via arc bridge.
TEST_F(ArcBluetoothBridgeTest, LEDeviceFound) {
  base::test::ScopedChromeOSVersionInfo version(
      "CHROMEOS_ARC_ANDROID_SDK_VERSION=28", base::Time::Now());

  EXPECT_EQ(0u, fake_bluetooth_instance_->le_device_found_data().size());
  StartDiscovery();
  AddTestDevice();
  EXPECT_EQ(3u, fake_bluetooth_instance_->le_device_found_data().size());

  const auto& le_device_found_data =
      fake_bluetooth_instance_->le_device_found_data().back();
  const mojom::BluetoothAddressPtr& addr = le_device_found_data->addr();
  const std::vector<uint8_t>& eir = le_device_found_data->eir();

  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            addr->To<std::string>());
  EXPECT_EQ(kEIR, eir);
  EXPECT_EQ(kTestRssi, le_device_found_data->rssi());

  ChangeTestDeviceRssi(kTestRssi2);
  EXPECT_EQ(4u, fake_bluetooth_instance_->le_device_found_data().size());
  EXPECT_EQ(kTestRssi2,
            fake_bluetooth_instance_->le_device_found_data().back()->rssi());
}

// If ARC starts the connection by LEConnect(), OnLEConnectionStateChange()
// should be invoked when the connection is up/down. OnConnectionStateChanged()
// should always be invoked when the physical link state changed.
TEST_F(ArcBluetoothBridgeTest, DeviceConnectStateChangedAfterLEConnectReuqest) {
  StartDiscovery();
  AddTestDevice();
  arc_bluetooth_bridge_->ConnectLEDevice(mojom::BluetoothAddress::From(
      std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress)));

  // OnConnectionStateChanged() should be invoked.
  ASSERT_EQ(1u,
            fake_bluetooth_instance_->connection_state_changed_data().size());
  const auto& connected_data =
      fake_bluetooth_instance_->connection_state_changed_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            connected_data->addr()->To<std::string>());
  EXPECT_EQ(device::BLUETOOTH_TRANSPORT_LE, connected_data->device_type());
  EXPECT_EQ(true, connected_data->connected());

  // OnLEConnectionStateChange() should be invoked.
  ASSERT_EQ(1u,
            fake_bluetooth_instance_->le_connection_state_change_data().size());
  const auto& le_connected_data =
      fake_bluetooth_instance_->le_connection_state_change_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            le_connected_data->addr()->To<std::string>());
  EXPECT_EQ(true, le_connected_data->connected());

  // Device is disconnected.
  ChangeTestDeviceConnected(false);

  // OnConnectionStateChanged() should be invoked.
  ASSERT_EQ(2u,
            fake_bluetooth_instance_->connection_state_changed_data().size());
  const auto& disconnected_data =
      fake_bluetooth_instance_->connection_state_changed_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            disconnected_data->addr()->To<std::string>());
  EXPECT_EQ(device::BLUETOOTH_TRANSPORT_LE, disconnected_data->device_type());
  EXPECT_EQ(false, disconnected_data->connected());

  // OnLEConnectionStateChange() should be invoked.
  ASSERT_EQ(2u,
            fake_bluetooth_instance_->le_connection_state_change_data().size());
  const auto& le_disconnected_data =
      fake_bluetooth_instance_->le_connection_state_change_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            le_disconnected_data->addr()->To<std::string>());
  EXPECT_EQ(false, le_disconnected_data->connected());
}

// If the connection is up/down and is not requested by ARC (e.g., in the case
// that another app in CrOS starts the connection, or it is an incoming
// connection), OnLEConnectionStateChange() should not be invoked.
// OnConnectionStateChanged() should always be invoked when the physical link
// state changed.
TEST_F(ArcBluetoothBridgeTest,
       DeviceConnectStateChangedWithoutLEConnectRequest) {
  StartDiscovery();
  AddTestDevice();
  ChangeTestDeviceConnected(true);

  // OnConnectionStateChanged() should be invoked.
  ASSERT_EQ(1u,
            fake_bluetooth_instance_->connection_state_changed_data().size());
  const auto& connected_data =
      fake_bluetooth_instance_->connection_state_changed_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            connected_data->addr()->To<std::string>());
  EXPECT_EQ(device::BLUETOOTH_TRANSPORT_LE, connected_data->device_type());
  EXPECT_EQ(true, connected_data->connected());

  // OnLEConnectionStateChange() should not be invoked.
  ASSERT_EQ(0u,
            fake_bluetooth_instance_->le_connection_state_change_data().size());

  // Device is disconnected.
  ChangeTestDeviceConnected(false);

  // OnConnectionStateChanged() should be invoked.
  ASSERT_EQ(2u,
            fake_bluetooth_instance_->connection_state_changed_data().size());
  const auto& disconnected_data =
      fake_bluetooth_instance_->connection_state_changed_data().back();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            disconnected_data->addr()->To<std::string>());
  EXPECT_EQ(device::BLUETOOTH_TRANSPORT_LE, disconnected_data->device_type());
  EXPECT_EQ(false, disconnected_data->connected());

  // OnLEConnectionStateChange() should not be invoked.
  ASSERT_EQ(0u,
            fake_bluetooth_instance_->le_connection_state_change_data().size());
}

// Invoke GetGattDB and check correctness of the GattDB sent via arc bridge.
TEST_F(ArcBluetoothBridgeTest, GetGattDB) {
  StartDiscovery();
  AddTestDevice();

  arc_bluetooth_bridge_->GetGattDB(mojom::BluetoothAddress::From(
      std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress)));
  EXPECT_EQ(1u, fake_bluetooth_instance_->gatt_db_result().size());

  const mojom::BluetoothAddressPtr& addr =
      fake_bluetooth_instance_->gatt_db_result().back()->remote_addr();
  EXPECT_EQ(std::string(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress),
            addr->To<std::string>());

  // HeartRateService in bluez::FakeBluetoothDeviceClient consists of
  // Service: HeartRateService
  //     Characteristic: HeartRateMeasurement
  //         Descriptor: ClientCharacteristicConfiguration
  //     Characteristic: BodySensorLocation
  //     Characteristic: HeartRateControlPoint
  const std::vector<mojom::BluetoothGattDBElementPtr>& db =
      fake_bluetooth_instance_->gatt_db_result().back()->db();
  EXPECT_EQ(5u, db.size());

  EXPECT_EQ(device::BluetoothUUID(
                bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
            db[0]->uuid);
  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_PRIMARY_SERVICE,
            db[0]->type);

  EXPECT_EQ(device::BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                                      kHeartRateMeasurementUUID),
            db[1]->uuid);
  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
            db[1]->type);
  EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_NOTIFY |
                device::BluetoothGattCharacteristic::PROPERTY_INDICATE,
            db[1]->properties);

  EXPECT_EQ(device::BluetoothUUID(bluez::FakeBluetoothGattDescriptorClient::
                                      kClientCharacteristicConfigurationUUID),
            db[2]->uuid);
  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_DESCRIPTOR,
            db[2]->type);

  EXPECT_EQ(device::BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                                      kBodySensorLocationUUID),
            db[3]->uuid);
  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
            db[3]->type);
  EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_READ,
            db[3]->properties);

  EXPECT_EQ(device::BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                                      kHeartRateControlPointUUID),
            db[4]->uuid);
  EXPECT_EQ(mojom::BluetoothGattDBAttributeType::BTGATT_DB_CHARACTERISTIC,
            db[4]->type);
  EXPECT_EQ(device::BluetoothGattCharacteristic::PROPERTY_WRITE,
            db[4]->properties);
}

// Invoke multi advertisement methods and make sure they are going down to the
// D-Bus clients.
TEST_F(ArcBluetoothBridgeTest, SingleAdvertisement) {
  int32_t handle = ReserveAdvertisementHandle();
  EXPECT_NE(kFailureAdvHandle, handle);
  EXPECT_EQ(0, NumActiveAdvertisements());

  auto adv_data = std::make_unique<device::BluetoothAdvertisement::Data>(
      device::BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST);
  mojom::BluetoothGattStatus status =
      EnableAdvertisement(handle, std::move(adv_data));
  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
  EXPECT_EQ(1, NumActiveAdvertisements());

  status = DisableAdvertisement(handle);
  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
  EXPECT_EQ(0, NumActiveAdvertisements());

  status = ReleaseAdvertisementHandle(handle);
  EXPECT_EQ(mojom::BluetoothGattStatus::GATT_SUCCESS, status);
  EXPECT_EQ(0, NumActiveAdvertisements());
}

TEST_F(ArcBluetoothBridgeTest, ServiceChanged) {
  // Set up device and service
  StartDiscovery();
  AddTestDevice();

  bluez::BluezDBusManager* dbus_manager = bluez::BluezDBusManager::Get();
  auto* fake_bluetooth_gatt_service_client =
      static_cast<bluez::FakeBluetoothGattServiceClient*>(
      dbus_manager->GetBluetoothGattServiceClient());

  device::BluetoothDevice* device = adapter_->GetDevices()[0];
  device::BluetoothRemoteGattService* service =
      device->GetGattService(fake_bluetooth_gatt_service_client->GetHeartRateServicePath().value());

  // When OnServiceChanged is called, service changed flag will be set
  // true, while reset_service_changed_flag will set this flag to false.
  // Here is to test whether OnServiceChanged is called after GattServiceAdded
  // and GattServiceRemoved is called.
  fake_bluetooth_instance_->reset_service_changed_flag();
  EXPECT_FALSE(fake_bluetooth_instance_->get_service_changed_flag());
  arc_bluetooth_bridge_->GattServiceAdded(adapter_.get(), device, service);
  EXPECT_TRUE(fake_bluetooth_instance_->get_service_changed_flag());

  fake_bluetooth_instance_->reset_service_changed_flag();
  EXPECT_FALSE(fake_bluetooth_instance_->get_service_changed_flag());
  arc_bluetooth_bridge_->GattServiceRemoved(adapter_.get(), device, service);
  EXPECT_TRUE(fake_bluetooth_instance_->get_service_changed_flag());

  fake_bluetooth_instance_->reset_service_changed_flag();
  EXPECT_FALSE(fake_bluetooth_instance_->get_service_changed_flag());
  arc_bluetooth_bridge_->GattServiceChanged(adapter_.get(), service);
  EXPECT_TRUE(fake_bluetooth_instance_->get_service_changed_flag());
}

TEST_F(ArcBluetoothBridgeTest, ReadMissingDescriptorFailsGracefully) {
  base::RunLoop run_loop;

  // Pass clearly invalid values to guarantee that we won't be able to find a
  // valid GATT descriptor.
  arc_bluetooth_bridge_->ReadGattDescriptor(
      /*remote_addr=*/mojom::BluetoothAddress::New(),
      /*service_id=*/mojom::BluetoothGattServiceID::New(),
      /*char_id=*/mojom::BluetoothGattID::New(),
      /*desc_id=*/mojom::BluetoothGattID::New(),
      base::BindOnce(
          [](base::RepeatingClosure quit_closure,
             mojom::BluetoothGattValuePtr value) {
            ASSERT_TRUE(value);
            EXPECT_TRUE(value->value.empty());
            EXPECT_EQ(value->status, mojom::BluetoothGattStatus::GATT_FAILURE);
            quit_closure.Run();
          },
          run_loop.QuitClosure()));
  run_loop.Run();
}

TEST_F(ArcBluetoothBridgeTest, WritingMissingDescriptorFailsGracefully) {
  base::RunLoop run_loop;

  // Pass clearly invalid values to guarantee that we won't be able to find a
  // valid GATT descriptor.
  arc_bluetooth_bridge_->WriteGattDescriptor(
      /*remote_addr=*/mojom::BluetoothAddress::New(),
      /*service_id=*/mojom::BluetoothGattServiceID::New(),
      /*char_id=*/mojom::BluetoothGattID::New(),
      /*desc_id=*/mojom::BluetoothGattID::New(),
      /*value=*/mojom::BluetoothGattValue::New(),
      base::BindOnce(
          [](base::RepeatingClosure quit_closure,
             mojom::BluetoothGattStatus status) {
            EXPECT_EQ(status, mojom::BluetoothGattStatus::GATT_FAILURE);
            quit_closure.Run();
          },
          run_loop.QuitClosure()));
  run_loop.Run();
}

TEST_F(ArcBluetoothBridgeTest, ReadMissingCharacteristicFailsGracefully) {
  base::RunLoop run_loop;

  // Pass clearly invalid values to guarantee that we won't be able to find a
  // valid GATT characteristic.
  arc_bluetooth_bridge_->ReadGattCharacteristic(
      /*remote_addr=*/mojom::BluetoothAddress::New(),
      /*service_id=*/mojom::BluetoothGattServiceID::New(),
      /*char_id=*/mojom::BluetoothGattID::New(),
      base::BindOnce(
          [](base::RepeatingClosure quit_closure,
             mojom::BluetoothGattValuePtr value) {
            ASSERT_TRUE(value);
            EXPECT_TRUE(value->value.empty());
            EXPECT_EQ(value->status, mojom::BluetoothGattStatus::GATT_FAILURE);
            quit_closure.Run();
          },
          run_loop.QuitClosure()));
  run_loop.Run();
}

TEST_F(ArcBluetoothBridgeTest, WriteMissingCharacteristicFailsGracefully) {
  base::RunLoop run_loop;

  // Pass clearly invalid values to guarantee that we won't be able to find a
  // valid GATT characteristic.
  arc_bluetooth_bridge_->WriteGattCharacteristic(
      /*remote_addr=*/mojom::BluetoothAddress::New(),
      /*service_id=*/mojom::BluetoothGattServiceID::New(),
      /*char_id=*/mojom::BluetoothGattID::New(),
      /*value=*/mojom::BluetoothGattValue::New(),
      /*prepare=*/false,
      base::BindOnce(
          [](base::RepeatingClosure quit_closure,
             mojom::BluetoothGattStatus status) {
            EXPECT_EQ(status, mojom::BluetoothGattStatus::GATT_FAILURE);
            quit_closure.Run();
          },
          run_loop.QuitClosure()));
  run_loop.Run();
}

TEST_F(ArcBluetoothBridgeTest, SetDiscoverabilityAndTimeout) {
  // Setting discoverable without setting the timeout first is not allowed
  arc_bluetooth_bridge_->SetAdapterProperty(
      mojom::BluetoothProperty::NewAdapterScanMode(
          mojom::BluetoothScanMode::CONNECTABLE_DISCOVERABLE));
  ASSERT_FALSE(adapter_->IsDiscoverable());

  // Setting discoverable after setting the timeout is OK
  // Timeout of zero is OK
  arc_bluetooth_bridge_->SetAdapterProperty(
      mojom::BluetoothProperty::NewDiscoveryTimeout(0));
  arc_bluetooth_bridge_->SetAdapterProperty(
      mojom::BluetoothProperty::NewAdapterScanMode(
          mojom::BluetoothScanMode::CONNECTABLE_DISCOVERABLE));
  ASSERT_TRUE(adapter_->IsDiscoverable());
}

// If we are not discovering or scanning, we shouldn't be forwarding
// LEDeviceFound events.
TEST_F(ArcBluetoothBridgeTest, NoLEDeviceFoundIfNotScanning) {
  EXPECT_EQ(0u, fake_bluetooth_instance_->le_device_found_data().size());
  AddTestDevice();
  EXPECT_EQ(0u, fake_bluetooth_instance_->le_device_found_data().size());
}

}  // namespace arc