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

#include "base/memory/scoped_vector.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "chromeos/dbus/fake_bluetooth_adapter_client.h"
#include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
#include "chromeos/dbus/fake_bluetooth_device_client.h"
#include "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
#include "chromeos/dbus/fake_bluetooth_gatt_descriptor_client.h"
#include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
#include "chromeos/dbus/fake_bluetooth_input_client.h"
#include "chromeos/dbus/fake_dbus_thread_manager.h"
#include "dbus/object_path.h"
#include "device/bluetooth/bluetooth_adapter.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/bluetooth_device.h"
#include "device/bluetooth/bluetooth_gatt_characteristic.h"
#include "device/bluetooth/bluetooth_gatt_connection.h"
#include "device/bluetooth/bluetooth_gatt_descriptor.h"
#include "device/bluetooth/bluetooth_gatt_notify_session.h"
#include "device/bluetooth/bluetooth_gatt_service.h"
#include "device/bluetooth/bluetooth_uuid.h"
#include "testing/gtest/include/gtest/gtest.h"

using device::BluetoothAdapter;
using device::BluetoothDevice;
using device::BluetoothGattCharacteristic;
using device::BluetoothGattConnection;
using device::BluetoothGattDescriptor;
using device::BluetoothGattService;
using device::BluetoothGattNotifySession;
using device::BluetoothUUID;

namespace chromeos {

namespace {

const BluetoothUUID kHeartRateMeasurementUUID(
    FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID);
const BluetoothUUID kBodySensorLocationUUID(
    FakeBluetoothGattCharacteristicClient::kBodySensorLocationUUID);
const BluetoothUUID kHeartRateControlPointUUID(
    FakeBluetoothGattCharacteristicClient::kHeartRateControlPointUUID);

// Compares GATT characteristic/descriptor values. Returns true, if the values
// are equal.
bool ValuesEqual(const std::vector<uint8>& value0,
                 const std::vector<uint8>& value1) {
  if (value0.size() != value1.size())
    return false;
  for (size_t i = 0; i < value0.size(); ++i)
    if (value0[i] != value1[i])
      return false;
  return true;
}

class TestDeviceObserver : public BluetoothDevice::Observer {
 public:
  TestDeviceObserver(scoped_refptr<BluetoothAdapter> adapter,
                     BluetoothDevice* device)
      : gatt_service_added_count_(0),
        gatt_service_removed_count_(0),
        device_address_(device->GetAddress()),
        adapter_(adapter) {
    device->AddObserver(this);
  }

  virtual ~TestDeviceObserver() {
    BluetoothDevice* device = adapter_->GetDevice(device_address_);
    if (device)
      device->RemoveObserver(this);
  }

  // BluetoothDevice::Observer overrides.
  virtual void GattServiceAdded(
      BluetoothDevice* device,
      BluetoothGattService* service) OVERRIDE {
    ASSERT_EQ(device_address_, device->GetAddress());

    ++gatt_service_added_count_;
    last_gatt_service_id_ = service->GetIdentifier();
    last_gatt_service_uuid_ = service->GetUUID();

    EXPECT_FALSE(service->IsLocal());
    EXPECT_TRUE(service->IsPrimary());

    EXPECT_EQ(device->GetGattService(last_gatt_service_id_), service);

    QuitMessageLoop();
  }

  virtual void GattServiceRemoved(
      BluetoothDevice* device,
      BluetoothGattService* service) OVERRIDE {
    ASSERT_EQ(device_address_, device->GetAddress());

    ++gatt_service_removed_count_;
    last_gatt_service_id_ = service->GetIdentifier();
    last_gatt_service_uuid_ = service->GetUUID();

    EXPECT_FALSE(service->IsLocal());
    EXPECT_TRUE(service->IsPrimary());

    // The device should return NULL for this service.
    EXPECT_FALSE(device->GetGattService(last_gatt_service_id_));

    QuitMessageLoop();
  }

  int gatt_service_added_count_;
  int gatt_service_removed_count_;
  std::string last_gatt_service_id_;
  BluetoothUUID last_gatt_service_uuid_;

 private:
  // Some tests use a message loop since background processing is simulated;
  // break out of those loops.
  void QuitMessageLoop() {
    if (base::MessageLoop::current() &&
        base::MessageLoop::current()->is_running())
      base::MessageLoop::current()->Quit();
  }

  std::string device_address_;
  scoped_refptr<BluetoothAdapter> adapter_;
};

class TestGattServiceObserver : public BluetoothGattService::Observer {
 public:
  TestGattServiceObserver(scoped_refptr<BluetoothAdapter> adapter,
                          BluetoothDevice* device,
                          BluetoothGattService* service)
      : gatt_service_changed_count_(0),
        gatt_characteristic_added_count_(0),
        gatt_characteristic_removed_count_(0),
        gatt_characteristic_value_changed_count_(0),
        gatt_descriptor_added_count_(0),
        gatt_descriptor_removed_count_(0),
        gatt_descriptor_value_changed_count_(0),
        device_address_(device->GetAddress()),
        gatt_service_id_(service->GetIdentifier()),
        adapter_(adapter) {
    service->AddObserver(this);
  }

  virtual ~TestGattServiceObserver() {
    // See if either the device or the service even exist.
    BluetoothDevice* device = adapter_->GetDevice(device_address_);
    if (!device)
      return;

    BluetoothGattService* service = device->GetGattService(gatt_service_id_);
    if (!service)
      return;

    service->RemoveObserver(this);
  }

  // BluetoothGattService::Observer overrides.
  virtual void GattServiceChanged(BluetoothGattService* service) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());
    ++gatt_service_changed_count_;

    QuitMessageLoop();
  }

  virtual void GattCharacteristicAdded(
      BluetoothGattService* service,
      BluetoothGattCharacteristic* characteristic) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());

    ++gatt_characteristic_added_count_;
    last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    last_gatt_characteristic_uuid_ = characteristic->GetUUID();

    EXPECT_EQ(service->GetCharacteristic(last_gatt_characteristic_id_),
              characteristic);
    EXPECT_EQ(service, characteristic->GetService());

    QuitMessageLoop();
  }

  virtual void GattCharacteristicRemoved(
      BluetoothGattService* service,
      BluetoothGattCharacteristic* characteristic) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());

    ++gatt_characteristic_removed_count_;
    last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    last_gatt_characteristic_uuid_ = characteristic->GetUUID();

    // The service should return NULL for this characteristic.
    EXPECT_FALSE(service->GetCharacteristic(last_gatt_characteristic_id_));
    EXPECT_EQ(service, characteristic->GetService());

    QuitMessageLoop();
  }

  virtual void GattCharacteristicValueChanged(
      BluetoothGattService* service,
      BluetoothGattCharacteristic* characteristic,
      const std::vector<uint8>& value) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, service->GetIdentifier());

    ++gatt_characteristic_value_changed_count_;
    last_gatt_characteristic_id_ = characteristic->GetIdentifier();
    last_gatt_characteristic_uuid_ = characteristic->GetUUID();
    last_changed_characteristic_value_ = value;

    EXPECT_EQ(service->GetCharacteristic(last_gatt_characteristic_id_),
              characteristic);
    EXPECT_EQ(service, characteristic->GetService());

    QuitMessageLoop();
  }

  virtual void GattDescriptorAdded(
      BluetoothGattCharacteristic* characteristic,
      BluetoothGattDescriptor* descriptor) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());

    ++gatt_descriptor_added_count_;
    last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    last_gatt_descriptor_uuid_ = descriptor->GetUUID();

    EXPECT_EQ(characteristic->GetDescriptor(last_gatt_descriptor_id_),
              descriptor);
    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());

    QuitMessageLoop();
  }

  virtual void GattDescriptorRemoved(
      BluetoothGattCharacteristic* characteristic,
      BluetoothGattDescriptor* descriptor) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());

    ++gatt_descriptor_removed_count_;
    last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    last_gatt_descriptor_uuid_ = descriptor->GetUUID();

    // The characteristic should return NULL for this descriptor..
    EXPECT_FALSE(characteristic->GetDescriptor(last_gatt_descriptor_id_));
    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());

    QuitMessageLoop();
  }

  virtual void GattDescriptorValueChanged(
      BluetoothGattCharacteristic* characteristic,
      BluetoothGattDescriptor* descriptor,
      const std::vector<uint8>& value) OVERRIDE {
    ASSERT_EQ(gatt_service_id_, characteristic->GetService()->GetIdentifier());

    ++gatt_descriptor_value_changed_count_;
    last_gatt_descriptor_id_ = descriptor->GetIdentifier();
    last_gatt_descriptor_uuid_ = descriptor->GetUUID();
    last_changed_descriptor_value_ = value;

    EXPECT_EQ(characteristic->GetDescriptor(last_gatt_descriptor_id_),
              descriptor);
    EXPECT_EQ(characteristic, descriptor->GetCharacteristic());

    QuitMessageLoop();
  }

  int gatt_service_changed_count_;
  int gatt_characteristic_added_count_;
  int gatt_characteristic_removed_count_;
  int gatt_characteristic_value_changed_count_;
  int gatt_descriptor_added_count_;
  int gatt_descriptor_removed_count_;
  int gatt_descriptor_value_changed_count_;
  std::string last_gatt_characteristic_id_;
  BluetoothUUID last_gatt_characteristic_uuid_;
  std::vector<uint8> last_changed_characteristic_value_;
  std::string last_gatt_descriptor_id_;
  BluetoothUUID last_gatt_descriptor_uuid_;
  std::vector<uint8> last_changed_descriptor_value_;

 private:
  // Some tests use a message loop since background processing is simulated;
  // break out of those loops.
  void QuitMessageLoop() {
    if (base::MessageLoop::current() &&
        base::MessageLoop::current()->is_running())
      base::MessageLoop::current()->Quit();
  }

  std::string device_address_;
  std::string gatt_service_id_;
  scoped_refptr<BluetoothAdapter> adapter_;
};

}  // namespace

class BluetoothGattChromeOSTest : public testing::Test {
 public:
  BluetoothGattChromeOSTest()
      : fake_bluetooth_gatt_service_client_(NULL),
        success_callback_count_(0),
        error_callback_count_(0) {
  }

  virtual void SetUp() {
    FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager;
    fake_bluetooth_device_client_ = new FakeBluetoothDeviceClient;
    fake_bluetooth_gatt_service_client_ =
        new FakeBluetoothGattServiceClient;
    fake_bluetooth_gatt_characteristic_client_ =
        new FakeBluetoothGattCharacteristicClient;
    fake_bluetooth_gatt_descriptor_client_ =
        new FakeBluetoothGattDescriptorClient;
    fake_dbus_thread_manager->SetBluetoothDeviceClient(
        scoped_ptr<BluetoothDeviceClient>(
            fake_bluetooth_device_client_));
    fake_dbus_thread_manager->SetBluetoothGattServiceClient(
        scoped_ptr<BluetoothGattServiceClient>(
            fake_bluetooth_gatt_service_client_));
    fake_dbus_thread_manager->SetBluetoothGattCharacteristicClient(
        scoped_ptr<BluetoothGattCharacteristicClient>(
            fake_bluetooth_gatt_characteristic_client_));
    fake_dbus_thread_manager->SetBluetoothGattDescriptorClient(
        scoped_ptr<BluetoothGattDescriptorClient>(
            fake_bluetooth_gatt_descriptor_client_));
    fake_dbus_thread_manager->SetBluetoothAdapterClient(
        scoped_ptr<BluetoothAdapterClient>(new FakeBluetoothAdapterClient));
    fake_dbus_thread_manager->SetBluetoothInputClient(
        scoped_ptr<BluetoothInputClient>(new FakeBluetoothInputClient));
    fake_dbus_thread_manager->SetBluetoothAgentManagerClient(
        scoped_ptr<BluetoothAgentManagerClient>(
            new FakeBluetoothAgentManagerClient));
    DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager);

    GetAdapter();

    adapter_->SetPowered(
        true,
        base::Bind(&base::DoNothing),
        base::Bind(&base::DoNothing));
    ASSERT_TRUE(adapter_->IsPowered());
  }

  virtual void TearDown() {
    adapter_ = NULL;
    update_sessions_.clear();
    gatt_conn_.reset();
    DBusThreadManager::Shutdown();
  }

  void GetAdapter() {
    device::BluetoothAdapterFactory::GetAdapter(
        base::Bind(&BluetoothGattChromeOSTest::AdapterCallback,
                   base::Unretained(this)));
    ASSERT_TRUE(adapter_.get() != NULL);
    ASSERT_TRUE(adapter_->IsInitialized());
    ASSERT_TRUE(adapter_->IsPresent());
  }

  void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
    adapter_ = adapter;
  }

  void SuccessCallback() {
    ++success_callback_count_;
  }

  void ValueCallback(const std::vector<uint8>& value) {
    ++success_callback_count_;
    last_read_value_ = value;
  }

  void GattConnectionCallback(scoped_ptr<BluetoothGattConnection> conn) {
    ++success_callback_count_;
    gatt_conn_ = conn.Pass();
  }

  void NotifySessionCallback(scoped_ptr<BluetoothGattNotifySession> session) {
    ++success_callback_count_;
    update_sessions_.push_back(session.release());
    QuitMessageLoop();
  }

  void ErrorCallback() {
    ++error_callback_count_;
  }

  void DBusErrorCallback(const std::string& error_name,
                         const std::string& error_message) {
    ++error_callback_count_;
  }

  void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
    ++error_callback_count_;
  }

 protected:
  void QuitMessageLoop() {
    if (base::MessageLoop::current() &&
        base::MessageLoop::current()->is_running())
      base::MessageLoop::current()->Quit();
  }

  base::MessageLoop message_loop_;

  FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
  FakeBluetoothGattServiceClient* fake_bluetooth_gatt_service_client_;
  FakeBluetoothGattCharacteristicClient*
      fake_bluetooth_gatt_characteristic_client_;
  FakeBluetoothGattDescriptorClient* fake_bluetooth_gatt_descriptor_client_;
  scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
  ScopedVector<BluetoothGattNotifySession> update_sessions_;
  scoped_refptr<BluetoothAdapter> adapter_;

  int success_callback_count_;
  int error_callback_count_;
  std::vector<uint8> last_read_value_;
};

TEST_F(BluetoothGattChromeOSTest, GattConnection) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);
  ASSERT_FALSE(device->IsConnected());
  ASSERT_FALSE(gatt_conn_.get());
  ASSERT_EQ(0, success_callback_count_);
  ASSERT_EQ(0, error_callback_count_);

  device->CreateGattConnection(
      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                 base::Unretained(this)));

  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(device->IsConnected());
  ASSERT_TRUE(gatt_conn_.get());
  EXPECT_TRUE(gatt_conn_->IsConnected());
  EXPECT_EQ(FakeBluetoothDeviceClient::kLowEnergyAddress,
            gatt_conn_->GetDeviceAddress());

  gatt_conn_->Disconnect(
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)));
  EXPECT_EQ(2, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(device->IsConnected());
  EXPECT_FALSE(gatt_conn_->IsConnected());

  device->CreateGattConnection(
      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                 base::Unretained(this)));

  EXPECT_EQ(3, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(device->IsConnected());
  ASSERT_TRUE(gatt_conn_.get());
  EXPECT_TRUE(gatt_conn_->IsConnected());

  device->Disconnect(
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));

  EXPECT_EQ(4, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  ASSERT_TRUE(gatt_conn_.get());
  EXPECT_FALSE(gatt_conn_->IsConnected());

  device->CreateGattConnection(
      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                 base::Unretained(this)));

  EXPECT_EQ(5, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(device->IsConnected());
  EXPECT_TRUE(gatt_conn_->IsConnected());

  fake_bluetooth_device_client_->RemoveDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_TRUE(gatt_conn_.get());
  EXPECT_FALSE(gatt_conn_->IsConnected());
}

TEST_F(BluetoothGattChromeOSTest, GattServiceAddedAndRemoved) {
  // Create a fake LE device. We store the device pointer here because this is a
  // test. It's unsafe to do this in production as the device might get deleted.
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);
  EXPECT_EQ(0, observer.gatt_service_added_count_);
  EXPECT_EQ(0, observer.gatt_service_removed_count_);
  EXPECT_TRUE(observer.last_gatt_service_id_.empty());
  EXPECT_FALSE(observer.last_gatt_service_uuid_.IsValid());
  EXPECT_TRUE(device->GetGattServices().empty());

  // Expose the fake Heart Rate Service.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  EXPECT_EQ(1, observer.gatt_service_added_count_);
  EXPECT_EQ(0, observer.gatt_service_removed_count_);
  EXPECT_FALSE(observer.last_gatt_service_id_.empty());
  EXPECT_EQ(1U, device->GetGattServices().size());
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
      observer.last_gatt_service_uuid_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);
  EXPECT_FALSE(service->IsLocal());
  EXPECT_TRUE(service->IsPrimary());
  EXPECT_EQ(service, device->GetGattServices()[0]);
  EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));

  EXPECT_EQ(observer.last_gatt_service_uuid_, service->GetUUID());

  // Hide the service.
  observer.last_gatt_service_uuid_ = BluetoothUUID();
  observer.last_gatt_service_id_.clear();
  fake_bluetooth_gatt_service_client_->HideHeartRateService();

  EXPECT_EQ(1, observer.gatt_service_added_count_);
  EXPECT_EQ(1, observer.gatt_service_removed_count_);
  EXPECT_FALSE(observer.last_gatt_service_id_.empty());
  EXPECT_TRUE(device->GetGattServices().empty());
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
      observer.last_gatt_service_uuid_);

  EXPECT_EQ(NULL, device->GetGattService(observer.last_gatt_service_id_));

  // Expose the service again.
  observer.last_gatt_service_uuid_ = BluetoothUUID();
  observer.last_gatt_service_id_.clear();
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  EXPECT_EQ(2, observer.gatt_service_added_count_);
  EXPECT_EQ(1, observer.gatt_service_removed_count_);
  EXPECT_FALSE(observer.last_gatt_service_id_.empty());
  EXPECT_EQ(1U, device->GetGattServices().size());
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
      observer.last_gatt_service_uuid_);

  // The object |service| points to should have been deallocated. |device|
  // should contain a brand new instance.
  service = device->GetGattService(observer.last_gatt_service_id_);
  EXPECT_EQ(service, device->GetGattServices()[0]);
  EXPECT_FALSE(service->IsLocal());
  EXPECT_TRUE(service->IsPrimary());

  EXPECT_EQ(observer.last_gatt_service_uuid_, service->GetUUID());

  // Remove the device. The observer should be notified of the removed service.
  // |device| becomes invalid after this.
  observer.last_gatt_service_uuid_ = BluetoothUUID();
  observer.last_gatt_service_id_.clear();
  fake_bluetooth_device_client_->RemoveDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));

  EXPECT_EQ(2, observer.gatt_service_added_count_);
  EXPECT_EQ(2, observer.gatt_service_removed_count_);
  EXPECT_FALSE(observer.last_gatt_service_id_.empty());
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
      observer.last_gatt_service_uuid_);
  EXPECT_EQ(
      NULL, adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress));
}

TEST_F(BluetoothGattChromeOSTest, GattCharacteristicAddedAndRemoved) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_added_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(service->GetCharacteristics().empty());

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();

  // 3 characteristics should appear. Only 1 of the characteristics sends
  // value changed signals. Service changed should be fired once for
  // descriptor added.
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(3, service_observer.gatt_characteristic_added_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_EQ(3U, service->GetCharacteristics().size());

  // Hide the characteristics. 3 removed signals should be received.
  fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
  EXPECT_EQ(8, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(3, service_observer.gatt_characteristic_added_count_);
  EXPECT_EQ(3, service_observer.gatt_characteristic_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(service->GetCharacteristics().empty());

  // Re-expose the heart rate characteristics.
  fake_bluetooth_gatt_characteristic_client_->ExposeHeartRateCharacteristics(
      fake_bluetooth_gatt_service_client_->GetHeartRateServicePath());
  EXPECT_EQ(12, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(6, service_observer.gatt_characteristic_added_count_);
  EXPECT_EQ(3, service_observer.gatt_characteristic_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_EQ(3U, service->GetCharacteristics().size());

  // Hide the service. All characteristics should disappear.
  fake_bluetooth_gatt_service_client_->HideHeartRateService();
  EXPECT_EQ(16, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(6, service_observer.gatt_characteristic_added_count_);
  EXPECT_EQ(6, service_observer.gatt_characteristic_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);
}

TEST_F(BluetoothGattChromeOSTest, GattDescriptorAddedAndRemoved) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_added_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);

  EXPECT_TRUE(service->GetCharacteristics().empty());

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);

  // Only the Heart Rate Measurement characteristic has a descriptor.
  EXPECT_EQ(1, service_observer.gatt_descriptor_added_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);

  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetBodySensorLocationPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_TRUE(characteristic->GetDescriptors().empty());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateControlPointPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_TRUE(characteristic->GetDescriptors().empty());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateMeasurementPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(1U, characteristic->GetDescriptors().size());

  BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
  EXPECT_FALSE(descriptor->IsLocal());
  EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
            descriptor->GetUUID());
  EXPECT_EQ(descriptor->GetUUID(),
            service_observer.last_gatt_descriptor_uuid_);
  EXPECT_EQ(descriptor->GetIdentifier(),
            service_observer.last_gatt_descriptor_id_);

  // Hide the descriptor.
  fake_bluetooth_gatt_descriptor_client_->HideDescriptor(
      dbus::ObjectPath(descriptor->GetIdentifier()));
  EXPECT_TRUE(characteristic->GetDescriptors().empty());
  EXPECT_EQ(5, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(1, service_observer.gatt_descriptor_added_count_);
  EXPECT_EQ(1, service_observer.gatt_descriptor_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);

  // Expose the descriptor again.
  service_observer.last_gatt_descriptor_id_.clear();
  service_observer.last_gatt_descriptor_uuid_ = BluetoothUUID();
  fake_bluetooth_gatt_descriptor_client_->ExposeDescriptor(
      dbus::ObjectPath(characteristic->GetIdentifier()),
      FakeBluetoothGattDescriptorClient::
          kClientCharacteristicConfigurationUUID);
  EXPECT_EQ(6, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(1U, characteristic->GetDescriptors().size());
  EXPECT_EQ(2, service_observer.gatt_descriptor_added_count_);
  EXPECT_EQ(1, service_observer.gatt_descriptor_removed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);

  descriptor = characteristic->GetDescriptors()[0];
  EXPECT_FALSE(descriptor->IsLocal());
  EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
            descriptor->GetUUID());
  EXPECT_EQ(descriptor->GetUUID(), service_observer.last_gatt_descriptor_uuid_);
  EXPECT_EQ(descriptor->GetIdentifier(),
            service_observer.last_gatt_descriptor_id_);
}

TEST_F(BluetoothGattChromeOSTest, AdapterAddedAfterGattService) {
  // This unit test tests that all remote GATT objects are created for D-Bus
  // objects that were already exposed.
  adapter_ = NULL;
  ASSERT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());

  // Create the fake D-Bus objects.
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  while (!fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible())
    base::RunLoop().RunUntilIdle();
  ASSERT_TRUE(fake_bluetooth_gatt_service_client_->IsHeartRateVisible());
  ASSERT_TRUE(fake_bluetooth_gatt_characteristic_client_->IsHeartRateVisible());

  // Create the adapter. This should create all the GATT objects.
  GetAdapter();
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);
  EXPECT_EQ(1U, device->GetGattServices().size());

  BluetoothGattService* service = device->GetGattServices()[0];
  ASSERT_TRUE(service);
  EXPECT_FALSE(service->IsLocal());
  EXPECT_TRUE(service->IsPrimary());
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
      service->GetUUID());
  EXPECT_EQ(service, device->GetGattServices()[0]);
  EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));
  EXPECT_FALSE(service->IsLocal());
  EXPECT_EQ(3U, service->GetCharacteristics().size());

  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetBodySensorLocationPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattCharacteristicClient::
          kBodySensorLocationUUID),
      characteristic->GetUUID());
  EXPECT_FALSE(characteristic->IsLocal());
  EXPECT_TRUE(characteristic->GetDescriptors().empty());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateControlPointPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattCharacteristicClient::
          kHeartRateControlPointUUID),
      characteristic->GetUUID());
  EXPECT_FALSE(characteristic->IsLocal());
  EXPECT_TRUE(characteristic->GetDescriptors().empty());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateMeasurementPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(
      BluetoothUUID(FakeBluetoothGattCharacteristicClient::
          kHeartRateMeasurementUUID),
      characteristic->GetUUID());
  EXPECT_FALSE(characteristic->IsLocal());
  EXPECT_EQ(1U, characteristic->GetDescriptors().size());

  BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
  ASSERT_TRUE(descriptor);
  EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
            descriptor->GetUUID());
  EXPECT_FALSE(descriptor->IsLocal());
}

TEST_F(BluetoothGattChromeOSTest, GattCharacteristicValue) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();

  // Issue write request to non-writeable characteristics.
  service_observer.last_gatt_characteristic_id_.clear();
  service_observer.last_gatt_characteristic_uuid_ = BluetoothUUID();

  std::vector<uint8> write_value;
  write_value.push_back(0x01);
  BluetoothGattCharacteristic* characteristic =
      service->GetCharacteristic(fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateMeasurementPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_FALSE(characteristic->IsNotifying());
  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                GetHeartRateMeasurementPath().value(),
            characteristic->GetIdentifier());
  EXPECT_EQ(kHeartRateMeasurementUUID, characteristic->GetUUID());
  characteristic->WriteRemoteCharacteristic(
      write_value,
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(1, error_callback_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetBodySensorLocationPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                GetBodySensorLocationPath().value(),
            characteristic->GetIdentifier());
  EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
  characteristic->WriteRemoteCharacteristic(
      write_value,
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(2, error_callback_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  // Issue write request to writeable characteristic. The "Body Sensor Location"
  // characteristic does not send notifications and WriteValue does not result
  // in a CharacteristicValueChanged event, thus no such event should be
  // received.
  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateControlPointPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                GetHeartRateControlPointPath().value(),
            characteristic->GetIdentifier());
  EXPECT_EQ(kHeartRateControlPointUUID, characteristic->GetUUID());
  characteristic->WriteRemoteCharacteristic(
      write_value,
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_TRUE(service_observer.last_gatt_characteristic_id_.empty());
  EXPECT_FALSE(service_observer.last_gatt_characteristic_uuid_.IsValid());
  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(2, error_callback_count_);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  // Issue a read request. A successful read results in a
  // CharacteristicValueChanged notification.
  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetBodySensorLocationPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
                GetBodySensorLocationPath().value(),
            characteristic->GetIdentifier());
  EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
  characteristic->ReadRemoteCharacteristic(
      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(2, success_callback_count_);
  EXPECT_EQ(2, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(ValuesEqual(characteristic->GetValue(), last_read_value_));
}

TEST_F(BluetoothGattChromeOSTest, GattCharacteristicProperties) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_TRUE(service->GetCharacteristics().empty());

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();

  BluetoothGattCharacteristic *characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetBodySensorLocationPath().value());
  EXPECT_EQ(BluetoothGattCharacteristic::kPropertyRead,
            characteristic->GetProperties());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateControlPointPath().value());
  EXPECT_EQ(BluetoothGattCharacteristic::kPropertyWrite,
            characteristic->GetProperties());

  characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateMeasurementPath().value());
  EXPECT_EQ(BluetoothGattCharacteristic::kPropertyNotify,
            characteristic->GetProperties());
}

TEST_F(BluetoothGattChromeOSTest, GattDescriptorValue) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device = adapter_->GetDevice(
      FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(0, service_observer.gatt_descriptor_value_changed_count_);
  EXPECT_TRUE(service->GetCharacteristics().empty());

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);

  // Only the Heart Rate Measurement characteristic has a descriptor.
  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->
          GetHeartRateMeasurementPath().value());
  ASSERT_TRUE(characteristic);
  EXPECT_EQ(1U, characteristic->GetDescriptors().size());

  BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
  EXPECT_FALSE(descriptor->IsLocal());
  EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
            descriptor->GetUUID());

  std::vector<uint8> desc_value;
  desc_value.push_back(1);
  desc_value.push_back(0);

  /* The cached value will be empty until the first read request */
  EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
  EXPECT_TRUE(descriptor->GetValue().empty());

  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(last_read_value_.empty());

  // Read value. GattDescriptorValueChanged event will be sent after a
  // successful read.
  descriptor->ReadRemoteDescriptor(
      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
  EXPECT_TRUE(ValuesEqual(desc_value, descriptor->GetValue()));
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(1, service_observer.gatt_descriptor_value_changed_count_);

  // Write value. Writes to this descriptor will fail.
  desc_value[0] = 0x03;
  descriptor->WriteRemoteDescriptor(
      desc_value,
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(1, error_callback_count_);
  EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
  EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(1, service_observer.gatt_descriptor_value_changed_count_);

  // Read new value.
  descriptor->ReadRemoteDescriptor(
      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(2, success_callback_count_);
  EXPECT_EQ(1, error_callback_count_);
  EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
  EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
  EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
  EXPECT_EQ(2, service_observer.gatt_descriptor_value_changed_count_);
}

TEST_F(BluetoothGattChromeOSTest, NotifySessions) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device =
      adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();

  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
          .value());
  ASSERT_TRUE(characteristic);
  EXPECT_FALSE(characteristic->IsNotifying());
  EXPECT_TRUE(update_sessions_.empty());

  // Request to start notifications.
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));

  // The operation still hasn't completed but we should have received the first
  // notification.
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(update_sessions_.empty());

  // Send a two more requests, which should get queued.
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(update_sessions_.empty());
  EXPECT_TRUE(characteristic->IsNotifying());

  // Run the main loop. The initial call should complete. The queued call should
  // succeed immediately.
  base::MessageLoop::current()->Run();

  EXPECT_EQ(3, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_EQ(3U, update_sessions_.size());

  // Notifications should be getting sent regularly now.
  base::MessageLoop::current()->Run();
  EXPECT_GT(service_observer.gatt_characteristic_value_changed_count_, 1);

  // Stop one of the sessions. The session should become inactive but the
  // characteristic should still be notifying.
  BluetoothGattNotifySession* session = update_sessions_[0];
  EXPECT_TRUE(session->IsActive());
  session->Stop(base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                           base::Unretained(this)));
  EXPECT_EQ(4, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_FALSE(session->IsActive());
  EXPECT_EQ(characteristic->GetIdentifier(),
            session->GetCharacteristicIdentifier());
  EXPECT_TRUE(characteristic->IsNotifying());

  // Delete another session. Characteristic should still be notifying.
  update_sessions_.pop_back();
  EXPECT_EQ(2U, update_sessions_.size());
  EXPECT_TRUE(characteristic->IsNotifying());
  EXPECT_FALSE(update_sessions_[0]->IsActive());
  EXPECT_TRUE(update_sessions_[1]->IsActive());

  // Clear the last session.
  update_sessions_.clear();
  EXPECT_TRUE(update_sessions_.empty());
  EXPECT_FALSE(characteristic->IsNotifying());

  success_callback_count_ = 0;
  service_observer.gatt_characteristic_value_changed_count_ = 0;

  // Enable notifications again.
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(update_sessions_.empty());
  EXPECT_TRUE(characteristic->IsNotifying());

  // Run the message loop. Notifications should begin.
  base::MessageLoop::current()->Run();

  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_EQ(1U, update_sessions_.size());
  EXPECT_TRUE(update_sessions_[0]->IsActive());
  EXPECT_TRUE(characteristic->IsNotifying());

  // Check that notifications are happening.
  base::MessageLoop::current()->Run();
  EXPECT_GT(service_observer.gatt_characteristic_value_changed_count_, 1);

  // Request another session. This should return immediately.
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(2, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(2U, update_sessions_.size());
  EXPECT_TRUE(update_sessions_[0]->IsActive());
  EXPECT_TRUE(update_sessions_[1]->IsActive());
  EXPECT_TRUE(characteristic->IsNotifying());

  // Hide the characteristic. The sessions should become inactive.
  fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
  EXPECT_EQ(2U, update_sessions_.size());
  EXPECT_FALSE(update_sessions_[0]->IsActive());
  EXPECT_FALSE(update_sessions_[1]->IsActive());
}

TEST_F(BluetoothGattChromeOSTest, NotifySessionsMadeInactive) {
  fake_bluetooth_device_client_->CreateDevice(
      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  BluetoothDevice* device =
      adapter_->GetDevice(FakeBluetoothDeviceClient::kLowEnergyAddress);
  ASSERT_TRUE(device);

  TestDeviceObserver observer(adapter_, device);

  // Expose the fake Heart Rate service. This will asynchronously expose
  // characteristics.
  fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
  ASSERT_EQ(1, observer.gatt_service_added_count_);

  BluetoothGattService* service =
      device->GetGattService(observer.last_gatt_service_id_);

  TestGattServiceObserver service_observer(adapter_, device, service);
  EXPECT_EQ(0, service_observer.gatt_characteristic_value_changed_count_);

  // Run the message loop so that the characteristics appear.
  base::MessageLoop::current()->Run();

  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
          .value());
  ASSERT_TRUE(characteristic);
  EXPECT_FALSE(characteristic->IsNotifying());
  EXPECT_TRUE(update_sessions_.empty());

  // Send several requests to start notifications.
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));

  // The operation still hasn't completed but we should have received the first
  // notification.
  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(characteristic->IsNotifying());
  EXPECT_TRUE(update_sessions_.empty());

  // Run the main loop. The initial call should complete. The queued calls
  // should succeed immediately.
  base::MessageLoop::current()->Run();

  EXPECT_EQ(4, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(characteristic->IsNotifying());
  EXPECT_EQ(4U, update_sessions_.size());

  for (int i = 0; i < 4; i++)
    EXPECT_TRUE(update_sessions_[0]->IsActive());

  // Stop notifications directly through the client. The sessions should get
  // marked as inactive.
  fake_bluetooth_gatt_characteristic_client_->StopNotify(
      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath(),
      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::DBusErrorCallback,
                 base::Unretained(this)));
  EXPECT_EQ(5, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_FALSE(characteristic->IsNotifying());
  EXPECT_EQ(4U, update_sessions_.size());

  for (int i = 0; i < 4; i++)
    EXPECT_FALSE(update_sessions_[0]->IsActive());

  // It should be possible to restart notifications and the call should reset
  // the session count and make a request through the client.
  update_sessions_.clear();
  success_callback_count_ = 0;
  service_observer.gatt_characteristic_value_changed_count_ = 0;
  characteristic->StartNotifySession(
      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
                 base::Unretained(this)),
      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                 base::Unretained(this)));

  EXPECT_EQ(0, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(characteristic->IsNotifying());
  EXPECT_TRUE(update_sessions_.empty());

  base::MessageLoop::current()->Run();

  EXPECT_EQ(1, success_callback_count_);
  EXPECT_EQ(0, error_callback_count_);
  EXPECT_EQ(1, service_observer.gatt_characteristic_value_changed_count_);
  EXPECT_TRUE(characteristic->IsNotifying());
  EXPECT_EQ(1U, update_sessions_.size());
  EXPECT_TRUE(update_sessions_[0]->IsActive());
}

}  // namespace chromeos