device/bluetooth/gatt_service_unittest.cc - chromium/src.git - Git at Google

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

 #include "device/bluetooth/gatt_service.h"

 #include "base/test/bind.h"
 #include "base/test/mock_callback.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_future.h"
 #include "device/bluetooth/public/cpp/bluetooth_uuid.h"
 #include "device/bluetooth/test/fake_local_gatt_characteristic.h"
 #include "device/bluetooth/test/fake_local_gatt_service.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {

 const char kServiceId[] = "12345678-1234-5678-9abc-def123456789";
 const char kCharacteristicUuid[] = "00001101-0000-1000-8000-00805f9b34fb";
 const char kTestDeviceName[] = "TestDeviceName";
 const char kTestDeviceAddress[] = "TestDeviceAddress";
 const std::vector<uint8_t> kReadCharacteristicValue = {0x01, 0x02, 0x03};
 const int kReadCharacteristicOffset = 0;

 std::unique_ptr<bluetooth::FakeLocalGattCharacteristic>
 CreateFakeCharacteristic(device::BluetoothLocalGattService* service) {
   return std::make_unique<bluetooth::FakeLocalGattCharacteristic>(
       /*characteristic_id=*/kCharacteristicUuid,
       /*characteristic_uuid=*/device::BluetoothUUID(kCharacteristicUuid),
       /*service=*/service,
       /*properties=*/
       device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
       /*property=*/
       device::BluetoothGattCharacteristic::Property::PROPERTY_READ);
 }

 std::unique_ptr<testing::NiceMock<device::MockBluetoothDevice>>
 CreateMockBluetoothDevice() {
   return std::make_unique<testing::NiceMock<device::MockBluetoothDevice>>(
       /*adapter=*/nullptr,
       /*class=*/0, kTestDeviceName, kTestDeviceAddress,
       /*paired=*/false,
       /*connected=*/false);
 }

 }  // namespace

 namespace bluetooth {

 class GattServiceTest : public testing::Test,
                         public mojom::GattServiceObserver {
  public:
   GattServiceTest() = default;
   ~GattServiceTest() override = default;
   GattServiceTest(const GattServiceTest&) = delete;
   GattServiceTest& operator=(const GattServiceTest&) = delete;

   void SetUp() override {
     fake_local_gatt_service_ = std::make_unique<FakeLocalGattService>(
         /*service_id=*/kServiceId,
         /*service_uuid=*/device::BluetoothUUID(kServiceId),
         /*is_primary=*/false);
     mock_bluetooth_adapter_ =
         base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
     ON_CALL(*mock_bluetooth_adapter_, GetGattService)
         .WillByDefault(testing::Return(nullptr));
     ON_CALL(*mock_bluetooth_adapter_, CreateLocalGattService)
         .WillByDefault(Invoke(this, &GattServiceTest::CreateLocalGattService));

     mojo::PendingReceiver<mojom::GattService> pending_gatt_service_receiver =
         remote_.BindNewPipeAndPassReceiver();
     mojo::PendingRemote<mojom::GattServiceObserver> pending_observer_remote =
         observer_.BindNewPipeAndPassRemote();
     gatt_service_ = std::make_unique<GattService>(
         std::move(pending_gatt_service_receiver),
         std::move(pending_observer_remote), device::BluetoothUUID(kServiceId),
         mock_bluetooth_adapter_.get(),
         base::BindOnce(&GattServiceTest::OnGattServiceInvalidated,
                        base::Unretained(this)));
   }

   base::WeakPtr<device::BluetoothLocalGattService> CreateLocalGattService(
       const device::BluetoothUUID& uuid,
       bool is_primary,
       device::BluetoothLocalGattService::Delegate* delegate) {
     // Although this method mocks the BluetoothAdapter's creation of
     // `BluetoothLocalGattService`s, and therefore there is no limit on
     // the number created, `GattService` is expected to only create and own
     // a single `BluetoothLocalGattService` instance, which we enforce in the
     // test with the CHECK below.
     CHECK_EQ(0, create_local_gatt_service_calls_);
     create_local_gatt_service_calls_++;
     delegate_ = delegate;
     return fake_local_gatt_service_->GetWeakPtr();
   }

   // mojo::GattServiceObserver:
   void OnLocalCharacteristicRead(
       bluetooth::mojom::DeviceInfoPtr remote_device,
       const device::BluetoothUUID& characteristic_uuid,
       const device::BluetoothUUID& service_uuid,
       uint32_t offset,
       OnLocalCharacteristicReadCallback callback) override {
     mojom::LocalCharacteristicReadResultPtr read_result;
     if (local_characteristic_read_error_code_.has_value()) {
       read_result = mojom::LocalCharacteristicReadResult::NewErrorCode(
           local_characteristic_read_error_code_.value());
     } else {
       CHECK(local_characteristic_read_value_.has_value());
       read_result = mojom::LocalCharacteristicReadResult::NewData(
           local_characteristic_read_value_.value());
     }

     std::move(callback).Run(std::move(read_result));
     std::move(on_local_characteristic_read_callback_).Run();
   }

   void OnGattServiceInvalidated(device::BluetoothUUID service_id) {
     EXPECT_EQ(device::BluetoothUUID(kServiceId), service_id);
     gatt_service_invalidated_ = true;
     std::move(on_gatt_service_invalidated_callback_).Run();
   }

   void SetGattServiceInvalidatedCallback(base::OnceClosure callback) {
     on_gatt_service_invalidated_callback_ = std::move(callback);
   }

   void CallCreateCharacteristic(
       bool gatt_service_exists,
       bool expected_success,
       device::BluetoothGattCharacteristic::Permissions permissions =
           device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
       device::BluetoothGattCharacteristic::Properties properties =
           device::BluetoothGattCharacteristic::Property::PROPERTY_READ) {
     if (gatt_service_exists) {
       // Simulate that the GATT service is created successfully, and is never
       // destroyed during the lifetime of this test.
       ON_CALL(*mock_bluetooth_adapter_, GetGattService)
           .WillByDefault(testing::Return(fake_local_gatt_service_.get()));
     } else {
       // Simulate the underlying platform GattService destruction.
       EXPECT_CALL(*mock_bluetooth_adapter_, GetGattService)
           .WillOnce(testing::Return(nullptr));
     }

     base::test::TestFuture<bool> future;
     remote_->CreateCharacteristic(
         /*characteristic_uuid=*/device::BluetoothUUID(kCharacteristicUuid),
         /*permissions=*/permissions,
         /*properties=*/properties, future.GetCallback());
     EXPECT_EQ(expected_success, future.Take());
     EXPECT_EQ(expected_success,
               (nullptr != fake_local_gatt_service_->GetCharacteristic(
                               kCharacteristicUuid)));
   }

   void SetOnLocalCharacteristicReadCallback(base::OnceClosure callback) {
     on_local_characteristic_read_callback_ = std::move(callback);
   }

   void SetOnLocalCharacteristicReadResult(
       std::optional<device::BluetoothGattService::GattErrorCode> error_code,
       std::optional<std::vector<uint8_t>> value) {
     local_characteristic_read_error_code_ = error_code;
     local_characteristic_read_value_ = value;
   }

  protected:
   bool gatt_service_invalidated_ = false;
   std::optional<device::BluetoothGattService::GattErrorCode>
       local_characteristic_read_error_code_;
   std::optional<std::vector<uint8_t>> local_characteristic_read_value_;
   base::OnceClosure on_local_characteristic_read_callback_;
   base::OnceClosure on_gatt_service_invalidated_callback_;
   int create_local_gatt_service_calls_ = 0;
   base::test::SingleThreadTaskEnvironment task_environment_;
   mojo::Remote<mojom::GattService> remote_;
   std::unique_ptr<FakeLocalGattService> fake_local_gatt_service_;
   scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>>
       mock_bluetooth_adapter_;
   std::unique_ptr<GattService> gatt_service_;
   raw_ptr<device::BluetoothLocalGattService::Delegate> delegate_;
   mojo::Receiver<mojom::GattServiceObserver> observer_{this};
 };

 TEST_F(GattServiceTest, CreateGattServiceOnConstruction) {
   EXPECT_TRUE(gatt_service_);
   EXPECT_EQ(1, create_local_gatt_service_calls_);
 }

 TEST_F(GattServiceTest, CreateCharacteristic_FailureIfGattServiceIsDestroyed) {
   // Simulate the underlying platform GattService destruction.
   EXPECT_CALL(*mock_bluetooth_adapter_, GetGattService)
       .WillOnce(testing::Return(nullptr));

   base::test::TestFuture<bool> future;
   remote_->CreateCharacteristic(
       /*characteristic_uuid=*/device::BluetoothUUID(kCharacteristicUuid),
       /*permissions=*/
       device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
       /*properties=*/
       device::BluetoothGattCharacteristic::Property::PROPERTY_READ,
       future.GetCallback());
   EXPECT_FALSE(future.Take());
 }

 TEST_F(GattServiceTest,
        CreateCharacteristic_FailureIfCreateGattCharacteristicFails) {
   CallCreateCharacteristic(/*gatt_service_exists=*/false,
                            /*expected_success=*/false);
 }

 TEST_F(GattServiceTest, CreateCharacteristic_SuccessIfCreated) {
   CallCreateCharacteristic(/*gatt_service_exists=*/true,
                            /*expected_success=*/true);
 }

 TEST_F(GattServiceTest,
        CreateCharacteristic_Success_MultiplePermissionsAndProperties) {
   device::BluetoothGattCharacteristic::Permissions permissions =
       device::BluetoothGattCharacteristic::Permission::PERMISSION_READ |
       device::BluetoothGattCharacteristic::Permission::PERMISSION_WRITE;
   device::BluetoothGattCharacteristic::Properties properties =
       device::BluetoothGattCharacteristic::Property::PROPERTY_READ |
       device::BluetoothGattCharacteristic::Property::PROPERTY_WRITE;

   CallCreateCharacteristic(/*gatt_service_exists=*/true,
                            /*expected_success=*/true, permissions, properties);

   auto* fake_characteristic =
       fake_local_gatt_service_->GetCharacteristic(kCharacteristicUuid);
   EXPECT_TRUE(fake_characteristic);
   EXPECT_EQ(properties, fake_characteristic->GetProperties());
   EXPECT_EQ(permissions, fake_characteristic->GetPermissions());
 }

 TEST_F(GattServiceTest, OnReadCharacteristic_Success) {
   // Simulate that the GATT service is created successfully, and is never
   // destroyed during the lifetime of this test. Simulate a successful
   // characteristic being added to the GATT service.
   CallCreateCharacteristic(/*gatt_service_exists=*/true,
                            /*expected_success=*/true);

   base::MockCallback<base::OnceClosure> mock_observer_callback;
   EXPECT_CALL(mock_observer_callback, Run).Times(1);
   SetOnLocalCharacteristicReadCallback(mock_observer_callback.Get());
   SetOnLocalCharacteristicReadResult(
       /*error_code=*/std::nullopt,
       /*value=*/kReadCharacteristicValue);

   base::RunLoop run_loop;
   auto mock_device = CreateMockBluetoothDevice();
   auto fake_characteristic =
       CreateFakeCharacteristic(fake_local_gatt_service_.get());

   delegate_->OnCharacteristicReadRequest(
       /*device=*/mock_device.get(),
       /*characteristic=*/fake_characteristic.get(),
       /*offset=*/kReadCharacteristicOffset,
       /*callback=*/
       base::BindLambdaForTesting(
           [&](std::optional<::device::BluetoothGattService::GattErrorCode>
                   error_code,
               const std::vector<uint8_t>& value) {
             EXPECT_FALSE(error_code.has_value());
             EXPECT_FALSE(value.empty());
             run_loop.Quit();
           }));

   run_loop.Run();
 }

 TEST_F(GattServiceTest, OnReadCharacteristic_Failure) {
   // Simulate that the GATT service is created successfully, and is never
   // destroyed during the lifetime of this test. Simulate a successful
   // characteristic being added to the GATT service.
   CallCreateCharacteristic(/*gatt_service_exists=*/true,
                            /*expected_success=*/true);

   base::MockCallback<base::OnceClosure> mock_observer_callback;
   EXPECT_CALL(mock_observer_callback, Run).Times(1);
   SetOnLocalCharacteristicReadCallback(mock_observer_callback.Get());
   SetOnLocalCharacteristicReadResult(
       /*error_code=*/device::BluetoothGattService::GattErrorCode::kFailed,
       /*value=*/std::nullopt);

   base::RunLoop run_loop;
   auto mock_device = CreateMockBluetoothDevice();
   auto fake_characteristic =
       CreateFakeCharacteristic(fake_local_gatt_service_.get());
   delegate_->OnCharacteristicReadRequest(
       /*device=*/mock_device.get(),
       /*characteristic=*/fake_characteristic.get(),
       /*offset=*/kReadCharacteristicOffset,
       /*callback=*/
       base::BindLambdaForTesting(
           [&](std::optional<::device::BluetoothGattService::GattErrorCode>
                   error_code,
               const std::vector<uint8_t>& value) {
             EXPECT_TRUE(error_code.has_value());
             EXPECT_TRUE(value.empty());
             run_loop.Quit();
           }));

   run_loop.Run();
 }

 TEST_F(GattServiceTest, MojoDisconnect_GattServiceRemote) {
   // Simulate that the GATT service is created successfully, and thus is always
   // accessible via `GetGattService()` calls.
   ON_CALL(*mock_bluetooth_adapter_, GetGattService)
       .WillByDefault(testing::Return(fake_local_gatt_service_.get()));

   base::RunLoop run_loop;
   SetGattServiceInvalidatedCallback(run_loop.QuitClosure());
   remote_.reset();
   run_loop.Run();

   EXPECT_TRUE(gatt_service_invalidated_);
   EXPECT_TRUE(fake_local_gatt_service_->WasDeleted());
 }

 TEST_F(GattServiceTest, MojoDisconnect_GattServiceObserverRemote) {
   // Simulate that the GATT service is created successfully, and thus is always
   // accessible via `GetGattService()` calls.
   ON_CALL(*mock_bluetooth_adapter_, GetGattService)
       .WillByDefault(testing::Return(fake_local_gatt_service_.get()));

   base::RunLoop run_loop;
   SetGattServiceInvalidatedCallback(run_loop.QuitClosure());
   observer_.reset();
   run_loop.Run();

   EXPECT_TRUE(gatt_service_invalidated_);
   EXPECT_TRUE(fake_local_gatt_service_->WasDeleted());
 }

 TEST_F(GattServiceTest, Register_Success) {
   // Simulate that the GATT service is created successfully, and is never
   // destroyed during the lifetime of this test.
   ON_CALL(*mock_bluetooth_adapter_, GetGattService)
       .WillByDefault(testing::Return(fake_local_gatt_service_.get()));
   fake_local_gatt_service_->set_should_registration_succeed(true);

   base::test::TestFuture<
       std::optional<device::BluetoothGattService::GattErrorCode>>
       future;
   remote_->Register(future.GetCallback());
   EXPECT_FALSE(future.Take());
 }

 TEST_F(GattServiceTest, Register_Failure) {
   // Simulate that the GATT service is created successfully, and is never
   // destroyed during the lifetime of this test.
   ON_CALL(*mock_bluetooth_adapter_, GetGattService)
       .WillByDefault(testing::Return(fake_local_gatt_service_.get()));
   fake_local_gatt_service_->set_should_registration_succeed(false);

   base::test::TestFuture<
       std::optional<device::BluetoothGattService::GattErrorCode>>
       future;
   remote_->Register(future.GetCallback());
   EXPECT_TRUE(future.Take());
 }

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

	#include "device/bluetooth/gatt_service.h"

	#include "base/test/bind.h"
	#include "base/test/mock_callback.h"
	#include "base/test/task_environment.h"
	#include "base/test/test_future.h"
	#include "device/bluetooth/public/cpp/bluetooth_uuid.h"
	#include "device/bluetooth/test/fake_local_gatt_characteristic.h"
	#include "device/bluetooth/test/fake_local_gatt_service.h"
	#include "device/bluetooth/test/mock_bluetooth_adapter.h"
	#include "device/bluetooth/test/mock_bluetooth_device.h"
	#include "mojo/public/cpp/bindings/remote.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {

	const char kServiceId[] = "12345678-1234-5678-9abc-def123456789";
	const char kCharacteristicUuid[] = "00001101-0000-1000-8000-00805f9b34fb";
	const char kTestDeviceName[] = "TestDeviceName";
	const char kTestDeviceAddress[] = "TestDeviceAddress";
	const std::vector<uint8_t> kReadCharacteristicValue = {0x01, 0x02, 0x03};
	const int kReadCharacteristicOffset = 0;

	std::unique_ptr<bluetooth::FakeLocalGattCharacteristic>
	CreateFakeCharacteristic(device::BluetoothLocalGattService* service) {
	return std::make_unique<bluetooth::FakeLocalGattCharacteristic>(
	/characteristic_id=/kCharacteristicUuid,
	/characteristic_uuid=/device::BluetoothUUID(kCharacteristicUuid),
	/service=/service,
	/properties=/
	device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
	/property=/
	device::BluetoothGattCharacteristic::Property::PROPERTY_READ);
	}

	std::unique_ptr<testing::NiceMock<device::MockBluetoothDevice>>
	CreateMockBluetoothDevice() {
	return std::make_unique<testing::NiceMock<device::MockBluetoothDevice>>(
	/adapter=/nullptr,
	/class=/0, kTestDeviceName, kTestDeviceAddress,
	/paired=/false,
	/connected=/false);
	}

	} // namespace

	namespace bluetooth {

	class GattServiceTest : public testing::Test,
	public mojom::GattServiceObserver {
	public:
	GattServiceTest() = default;
	~GattServiceTest() override = default;
	GattServiceTest(const GattServiceTest&) = delete;
	GattServiceTest& operator=(const GattServiceTest&) = delete;

	void SetUp() override {
	fake_local_gatt_service_ = std::make_unique<FakeLocalGattService>(
	/service_id=/kServiceId,
	/service_uuid=/device::BluetoothUUID(kServiceId),
	/is_primary=/false);
	mock_bluetooth_adapter_ =
	base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(nullptr));
	ON_CALL(*mock_bluetooth_adapter_, CreateLocalGattService)
	.WillByDefault(Invoke(this, &GattServiceTest::CreateLocalGattService));

	mojo::PendingReceiver<mojom::GattService> pending_gatt_service_receiver =
	remote_.BindNewPipeAndPassReceiver();
	mojo::PendingRemote<mojom::GattServiceObserver> pending_observer_remote =
	observer_.BindNewPipeAndPassRemote();
	gatt_service_ = std::make_unique<GattService>(
	std::move(pending_gatt_service_receiver),
	std::move(pending_observer_remote), device::BluetoothUUID(kServiceId),
	mock_bluetooth_adapter_.get(),
	base::BindOnce(&GattServiceTest::OnGattServiceInvalidated,
	base::Unretained(this)));
	}

	base::WeakPtr<device::BluetoothLocalGattService> CreateLocalGattService(
	const device::BluetoothUUID& uuid,
	bool is_primary,
	device::BluetoothLocalGattService::Delegate* delegate) {
	// Although this method mocks the BluetoothAdapter's creation of
	// `BluetoothLocalGattService`s, and therefore there is no limit on
	// the number created, `GattService` is expected to only create and own
	// a single `BluetoothLocalGattService` instance, which we enforce in the
	// test with the CHECK below.
	CHECK_EQ(0, create_local_gatt_service_calls_);
	create_local_gatt_service_calls_++;
	delegate_ = delegate;
	return fake_local_gatt_service_->GetWeakPtr();
	}

	// mojo::GattServiceObserver:
	void OnLocalCharacteristicRead(
	bluetooth::mojom::DeviceInfoPtr remote_device,
	const device::BluetoothUUID& characteristic_uuid,
	const device::BluetoothUUID& service_uuid,
	uint32_t offset,
	OnLocalCharacteristicReadCallback callback) override {
	mojom::LocalCharacteristicReadResultPtr read_result;
	if (local_characteristic_read_error_code_.has_value()) {
	read_result = mojom::LocalCharacteristicReadResult::NewErrorCode(
	local_characteristic_read_error_code_.value());
	} else {
	CHECK(local_characteristic_read_value_.has_value());
	read_result = mojom::LocalCharacteristicReadResult::NewData(
	local_characteristic_read_value_.value());
	}

	std::move(callback).Run(std::move(read_result));
	std::move(on_local_characteristic_read_callback_).Run();
	}

	void OnGattServiceInvalidated(device::BluetoothUUID service_id) {
	EXPECT_EQ(device::BluetoothUUID(kServiceId), service_id);
	gatt_service_invalidated_ = true;
	std::move(on_gatt_service_invalidated_callback_).Run();
	}

	void SetGattServiceInvalidatedCallback(base::OnceClosure callback) {
	on_gatt_service_invalidated_callback_ = std::move(callback);
	}

	void CallCreateCharacteristic(
	bool gatt_service_exists,
	bool expected_success,
	device::BluetoothGattCharacteristic::Permissions permissions =
	device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
	device::BluetoothGattCharacteristic::Properties properties =
	device::BluetoothGattCharacteristic::Property::PROPERTY_READ) {
	if (gatt_service_exists) {
	// Simulate that the GATT service is created successfully, and is never
	// destroyed during the lifetime of this test.
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(fake_local_gatt_service_.get()));
	} else {
	// Simulate the underlying platform GattService destruction.
	EXPECT_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillOnce(testing::Return(nullptr));
	}

	base::test::TestFuture<bool> future;
	remote_->CreateCharacteristic(
	/characteristic_uuid=/device::BluetoothUUID(kCharacteristicUuid),
	/permissions=/permissions,
	/properties=/properties, future.GetCallback());
	EXPECT_EQ(expected_success, future.Take());
	EXPECT_EQ(expected_success,
	(nullptr != fake_local_gatt_service_->GetCharacteristic(
	kCharacteristicUuid)));
	}

	void SetOnLocalCharacteristicReadCallback(base::OnceClosure callback) {
	on_local_characteristic_read_callback_ = std::move(callback);
	}

	void SetOnLocalCharacteristicReadResult(
	std::optional<device::BluetoothGattService::GattErrorCode> error_code,
	std::optional<std::vector<uint8_t>> value) {
	local_characteristic_read_error_code_ = error_code;
	local_characteristic_read_value_ = value;
	}

	protected:
	bool gatt_service_invalidated_ = false;
	std::optional<device::BluetoothGattService::GattErrorCode>
	local_characteristic_read_error_code_;
	std::optional<std::vector<uint8_t>> local_characteristic_read_value_;
	base::OnceClosure on_local_characteristic_read_callback_;
	base::OnceClosure on_gatt_service_invalidated_callback_;
	int create_local_gatt_service_calls_ = 0;
	base::test::SingleThreadTaskEnvironment task_environment_;
	mojo::Remote<mojom::GattService> remote_;
	std::unique_ptr<FakeLocalGattService> fake_local_gatt_service_;
	scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>>
	mock_bluetooth_adapter_;
	std::unique_ptr<GattService> gatt_service_;
	raw_ptr<device::BluetoothLocalGattService::Delegate> delegate_;
	mojo::Receiver<mojom::GattServiceObserver> observer_{this};
	};

	TEST_F(GattServiceTest, CreateGattServiceOnConstruction) {
	EXPECT_TRUE(gatt_service_);
	EXPECT_EQ(1, create_local_gatt_service_calls_);
	}

	TEST_F(GattServiceTest, CreateCharacteristic_FailureIfGattServiceIsDestroyed) {
	// Simulate the underlying platform GattService destruction.
	EXPECT_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillOnce(testing::Return(nullptr));

	base::test::TestFuture<bool> future;
	remote_->CreateCharacteristic(
	/characteristic_uuid=/device::BluetoothUUID(kCharacteristicUuid),
	/permissions=/
	device::BluetoothGattCharacteristic::Permission::PERMISSION_READ,
	/properties=/
	device::BluetoothGattCharacteristic::Property::PROPERTY_READ,
	future.GetCallback());
	EXPECT_FALSE(future.Take());
	}

	TEST_F(GattServiceTest,
	CreateCharacteristic_FailureIfCreateGattCharacteristicFails) {
	CallCreateCharacteristic(/gatt_service_exists=/false,
	/expected_success=/false);
	}

	TEST_F(GattServiceTest, CreateCharacteristic_SuccessIfCreated) {
	CallCreateCharacteristic(/gatt_service_exists=/true,
	/expected_success=/true);
	}

	TEST_F(GattServiceTest,
	CreateCharacteristic_Success_MultiplePermissionsAndProperties) {
	device::BluetoothGattCharacteristic::Permissions permissions =
	device::BluetoothGattCharacteristic::Permission::PERMISSION_READ \|
	device::BluetoothGattCharacteristic::Permission::PERMISSION_WRITE;
	device::BluetoothGattCharacteristic::Properties properties =
	device::BluetoothGattCharacteristic::Property::PROPERTY_READ \|
	device::BluetoothGattCharacteristic::Property::PROPERTY_WRITE;

	CallCreateCharacteristic(/gatt_service_exists=/true,
	/expected_success=/true, permissions, properties);

	auto* fake_characteristic =
	fake_local_gatt_service_->GetCharacteristic(kCharacteristicUuid);
	EXPECT_TRUE(fake_characteristic);
	EXPECT_EQ(properties, fake_characteristic->GetProperties());
	EXPECT_EQ(permissions, fake_characteristic->GetPermissions());
	}

	TEST_F(GattServiceTest, OnReadCharacteristic_Success) {
	// Simulate that the GATT service is created successfully, and is never
	// destroyed during the lifetime of this test. Simulate a successful
	// characteristic being added to the GATT service.
	CallCreateCharacteristic(/gatt_service_exists=/true,
	/expected_success=/true);

	base::MockCallback<base::OnceClosure> mock_observer_callback;
	EXPECT_CALL(mock_observer_callback, Run).Times(1);
	SetOnLocalCharacteristicReadCallback(mock_observer_callback.Get());
	SetOnLocalCharacteristicReadResult(
	/error_code=/std::nullopt,
	/value=/kReadCharacteristicValue);

	base::RunLoop run_loop;
	auto mock_device = CreateMockBluetoothDevice();
	auto fake_characteristic =
	CreateFakeCharacteristic(fake_local_gatt_service_.get());

	delegate_->OnCharacteristicReadRequest(
	/device=/mock_device.get(),
	/characteristic=/fake_characteristic.get(),
	/offset=/kReadCharacteristicOffset,
	/callback=/
	base::BindLambdaForTesting(
	[&](std::optional<::device::BluetoothGattService::GattErrorCode>
	error_code,
	const std::vector<uint8_t>& value) {
	EXPECT_FALSE(error_code.has_value());
	EXPECT_FALSE(value.empty());
	run_loop.Quit();
	}));

	run_loop.Run();
	}

	TEST_F(GattServiceTest, OnReadCharacteristic_Failure) {
	// Simulate that the GATT service is created successfully, and is never
	// destroyed during the lifetime of this test. Simulate a successful
	// characteristic being added to the GATT service.
	CallCreateCharacteristic(/gatt_service_exists=/true,
	/expected_success=/true);

	base::MockCallback<base::OnceClosure> mock_observer_callback;
	EXPECT_CALL(mock_observer_callback, Run).Times(1);
	SetOnLocalCharacteristicReadCallback(mock_observer_callback.Get());
	SetOnLocalCharacteristicReadResult(
	/error_code=/device::BluetoothGattService::GattErrorCode::kFailed,
	/value=/std::nullopt);

	base::RunLoop run_loop;
	auto mock_device = CreateMockBluetoothDevice();
	auto fake_characteristic =
	CreateFakeCharacteristic(fake_local_gatt_service_.get());
	delegate_->OnCharacteristicReadRequest(
	/device=/mock_device.get(),
	/characteristic=/fake_characteristic.get(),
	/offset=/kReadCharacteristicOffset,
	/callback=/
	base::BindLambdaForTesting(
	[&](std::optional<::device::BluetoothGattService::GattErrorCode>
	error_code,
	const std::vector<uint8_t>& value) {
	EXPECT_TRUE(error_code.has_value());
	EXPECT_TRUE(value.empty());
	run_loop.Quit();
	}));

	run_loop.Run();
	}

	TEST_F(GattServiceTest, MojoDisconnect_GattServiceRemote) {
	// Simulate that the GATT service is created successfully, and thus is always
	// accessible via `GetGattService()` calls.
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(fake_local_gatt_service_.get()));

	base::RunLoop run_loop;
	SetGattServiceInvalidatedCallback(run_loop.QuitClosure());
	remote_.reset();
	run_loop.Run();

	EXPECT_TRUE(gatt_service_invalidated_);
	EXPECT_TRUE(fake_local_gatt_service_->WasDeleted());
	}

	TEST_F(GattServiceTest, MojoDisconnect_GattServiceObserverRemote) {
	// Simulate that the GATT service is created successfully, and thus is always
	// accessible via `GetGattService()` calls.
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(fake_local_gatt_service_.get()));

	base::RunLoop run_loop;
	SetGattServiceInvalidatedCallback(run_loop.QuitClosure());
	observer_.reset();
	run_loop.Run();

	EXPECT_TRUE(gatt_service_invalidated_);
	EXPECT_TRUE(fake_local_gatt_service_->WasDeleted());
	}

	TEST_F(GattServiceTest, Register_Success) {
	// Simulate that the GATT service is created successfully, and is never
	// destroyed during the lifetime of this test.
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(fake_local_gatt_service_.get()));
	fake_local_gatt_service_->set_should_registration_succeed(true);

	base::test::TestFuture<
	std::optional<device::BluetoothGattService::GattErrorCode>>
	future;
	remote_->Register(future.GetCallback());
	EXPECT_FALSE(future.Take());
	}

	TEST_F(GattServiceTest, Register_Failure) {
	// Simulate that the GATT service is created successfully, and is never
	// destroyed during the lifetime of this test.
	ON_CALL(*mock_bluetooth_adapter_, GetGattService)
	.WillByDefault(testing::Return(fake_local_gatt_service_.get()));
	fake_local_gatt_service_->set_should_registration_succeed(false);

	base::test::TestFuture<
	std::optional<device::BluetoothGattService::GattErrorCode>>
	future;
	remote_->Register(future.GetCallback());
	EXPECT_TRUE(future.Take());
	}

	} // namespace bluetooth