// Copyright 2017 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 "device/fido/fido_ble_connection.h"

#include <utility>

#include "base/bind.h"
#include "base/run_loop.h"
#include "base/strings/string_piece.h"
#include "base/test/scoped_task_environment.h"
#include "build/build_config.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/test/bluetooth_test.h"
#include "device/bluetooth/test/mock_bluetooth_adapter.h"
#include "device/bluetooth/test/mock_bluetooth_device.h"
#include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
#include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
#include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
#include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
#include "device/fido/fido_ble_uuids.h"
#include "device/fido/test_callback_receiver.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

#if defined(OS_ANDROID)
#include "device/bluetooth/test/bluetooth_test_android.h"
#elif defined(OS_MACOSX)
#include "device/bluetooth/test/bluetooth_test_mac.h"
#elif defined(OS_WIN)
#include "device/bluetooth/test/bluetooth_test_win.h"
#elif defined(OS_CHROMEOS) || defined(OS_LINUX)
#include "device/bluetooth/test/bluetooth_test_bluez.h"
#endif

namespace device {

using ::testing::_;
using ::testing::ElementsAre;
using ::testing::Invoke;
using ::testing::IsEmpty;
using ::testing::Return;

using NiceMockBluetoothAdapter = ::testing::NiceMock<MockBluetoothAdapter>;
using NiceMockBluetoothDevice = ::testing::NiceMock<MockBluetoothDevice>;
using NiceMockBluetoothGattService =
    ::testing::NiceMock<MockBluetoothGattService>;
using NiceMockBluetoothGattCharacteristic =
    ::testing::NiceMock<MockBluetoothGattCharacteristic>;
using NiceMockBluetoothGattConnection =
    ::testing::NiceMock<MockBluetoothGattConnection>;
using NiceMockBluetoothGattNotifySession =
    ::testing::NiceMock<MockBluetoothGattNotifySession>;

namespace {

std::vector<uint8_t> ToByteVector(base::StringPiece str) {
  return std::vector<uint8_t>(str.begin(), str.end());
}

BluetoothDevice* GetMockDevice(MockBluetoothAdapter* adapter,
                               const std::string& address) {
  const std::vector<BluetoothDevice*> devices = adapter->GetMockDevices();
  auto found = std::find_if(devices.begin(), devices.end(),
                            [&address](const auto* device) {
                              return device->GetAddress() == address;
                            });
  return found != devices.end() ? *found : nullptr;
}

class TestConnectionStatusCallback {
 public:
  void OnStatus(bool status) {
    status_ = status;
    run_loop_->Quit();
  }

  bool WaitForResult() {
    run_loop_->Run();
    run_loop_.emplace();
    return status_;
  }

  FidoBleConnection::ConnectionStatusCallback GetCallback() {
    return base::BindRepeating(&TestConnectionStatusCallback::OnStatus,
                               base::Unretained(this));
  }

 private:
  bool status_ = false;
  base::Optional<base::RunLoop> run_loop_{base::in_place};
};

class TestReadCallback {
 public:
  void OnRead(std::vector<uint8_t> value) {
    value_ = std::move(value);
    run_loop_->Quit();
  }

  const std::vector<uint8_t> WaitForResult() {
    run_loop_->Run();
    run_loop_.emplace();
    return value_;
  }

  FidoBleConnection::ReadCallback GetCallback() {
    return base::BindRepeating(&TestReadCallback::OnRead,
                               base::Unretained(this));
  }

 private:
  std::vector<uint8_t> value_;
  base::Optional<base::RunLoop> run_loop_{base::in_place};
};

using TestReadControlPointLengthCallback =
    test::ValueCallbackReceiver<base::Optional<uint16_t>>;

using TestReadServiceRevisionsCallback =
    test::ValueCallbackReceiver<std::set<FidoBleConnection::ServiceRevision>>;

using TestWriteCallback = test::ValueCallbackReceiver<bool>;
}  // namespace

class FidoBleConnectionTest : public ::testing::Test {
 public:
  FidoBleConnectionTest() {
    ON_CALL(*adapter_, GetDevice(_))
        .WillByDefault(Invoke([this](const std::string& address) {
          return GetMockDevice(adapter_.get(), address);
        }));

    BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
  }

  void AddU2Device(const std::string& device_address) {
    auto u2f_device = std::make_unique<NiceMockBluetoothDevice>(
        adapter_.get(), /* bluetooth_class */ 0u,
        BluetoothTest::kTestDeviceNameU2f, device_address, /* paired */ true,
        /* connected */ false);
    u2f_device_ = u2f_device.get();
    adapter_->AddMockDevice(std::move(u2f_device));

    ON_CALL(*u2f_device_, GetGattServices())
        .WillByDefault(
            Invoke(u2f_device_, &MockBluetoothDevice::GetMockServices));

    ON_CALL(*u2f_device_, GetGattService(_))
        .WillByDefault(
            Invoke(u2f_device_, &MockBluetoothDevice::GetMockService));
    AddU2fService();
  }

  void SetupConnectingU2fDevice(const std::string& device_address) {
    auto run_cb_with_connection = [this, &device_address](
                                      const auto& callback,
                                      const auto& error_callback) {
      auto connection = std::make_unique<NiceMockBluetoothGattConnection>(
          adapter_, device_address);
      connection_ = connection.get();
      callback.Run(std::move(connection));
    };

    auto run_cb_with_notify_session = [this](const auto& callback,
                                             const auto& error_callback) {
      auto notify_session =
          std::make_unique<NiceMockBluetoothGattNotifySession>(
              u2f_status_->GetWeakPtr());
      notify_session_ = notify_session.get();
      callback.Run(std::move(notify_session));
    };

    ON_CALL(*u2f_device_, CreateGattConnection(_, _))
        .WillByDefault(Invoke(run_cb_with_connection));

    ON_CALL(*u2f_device_, IsGattServicesDiscoveryComplete())
        .WillByDefault(Return(true));

    ON_CALL(*u2f_status_, StartNotifySession(_, _))
        .WillByDefault(Invoke(run_cb_with_notify_session));
  }

  void SimulateDisconnect(const std::string& device_address) {
    if (u2f_device_->GetAddress() != device_address)
      return;

    u2f_device_->SetConnected(false);
    adapter_->NotifyDeviceChanged(u2f_device_);
  }

  void SimulateDeviceAddressChange(const std::string& old_address,
                                   const std::string& new_address) {
    if (!u2f_device_ || u2f_device_->GetAddress() != old_address)
      return;

    ON_CALL(*u2f_device_, GetAddress()).WillByDefault(Return(new_address));

    adapter_->NotifyDeviceChanged(u2f_device_);
    for (auto& observer : adapter_->GetObservers())
      observer.DeviceAddressChanged(adapter_.get(), u2f_device_, old_address);
  }

  void NotifyDeviceAdded(const std::string& device_address) {
    auto* device = adapter_->GetDevice(device_address);
    if (!device)
      return;

    for (auto& observer : adapter_->GetObservers())
      observer.DeviceAdded(adapter_.get(), device);
  }

  void NotifyStatusChanged(const std::vector<uint8_t>& value) {
    for (auto& observer : adapter_->GetObservers())
      observer.GattCharacteristicValueChanged(adapter_.get(), u2f_status_,
                                              value);
  }

  void SetNextReadControlPointLengthReponse(bool success,
                                            const std::vector<uint8_t>& value) {
    EXPECT_CALL(*u2f_control_point_length_, ReadRemoteCharacteristic(_, _))
        .WillOnce(Invoke([success, value](const auto& callback,
                                          const auto& error_callback) {
          success ? callback.Run(value)
                  : error_callback.Run(BluetoothGattService::GATT_ERROR_FAILED);
        }));
  }

  void SetNextReadServiceRevisionResponse(bool success,
                                          const std::vector<uint8_t>& value) {
    EXPECT_CALL(*u2f_service_revision_, ReadRemoteCharacteristic(_, _))
        .WillOnce(Invoke([success, value](const auto& callback,
                                          const auto& error_callback) {
          success ? callback.Run(value)
                  : error_callback.Run(BluetoothGattService::GATT_ERROR_FAILED);
        }));
  }

  void SetNextReadServiceRevisionBitfieldResponse(
      bool success,
      const std::vector<uint8_t>& value) {
    EXPECT_CALL(*u2f_service_revision_bitfield_, ReadRemoteCharacteristic(_, _))
        .WillOnce(Invoke([success, value](const auto& callback,
                                          const auto& error_callback) {
          success ? callback.Run(value)
                  : error_callback.Run(BluetoothGattService::GATT_ERROR_FAILED);
        }));
  }

  void SetNextWriteControlPointResponse(bool success) {
    EXPECT_CALL(*u2f_control_point_, WriteRemoteCharacteristic(_, _, _))
        .WillOnce(Invoke([success](const auto& data, const auto& callback,
                                   const auto& error_callback) {
          success ? callback.Run()
                  : error_callback.Run(BluetoothGattService::GATT_ERROR_FAILED);
        }));
  }

  void SetNextWriteServiceRevisionResponse(bool success) {
    EXPECT_CALL(*u2f_service_revision_bitfield_,
                WriteRemoteCharacteristic(_, _, _))
        .WillOnce(Invoke([success](const auto& data, const auto& callback,
                                   const auto& error_callback) {
          success ? callback.Run()
                  : error_callback.Run(BluetoothGattService::GATT_ERROR_FAILED);
        }));
  }

  void AddU2fService() {
    auto u2f_service = std::make_unique<NiceMockBluetoothGattService>(
        u2f_device_, "u2f_service", BluetoothUUID(kFidoServiceUUID),
        /* is_primary */ true, /* is_local */ false);
    u2f_service_ = u2f_service.get();
    u2f_device_->AddMockService(std::move(u2f_service));

    AddU2fCharacteristics();
  }

  void AddU2fCharacteristics() {
    const bool is_local = false;
    {
      auto u2f_control_point =
          std::make_unique<NiceMockBluetoothGattCharacteristic>(
              u2f_service_, "u2f_control_point",
              BluetoothUUID(kFidoControlPointUUID), is_local,
              BluetoothGattCharacteristic::PROPERTY_WRITE,
              BluetoothGattCharacteristic::PERMISSION_NONE);
      u2f_control_point_ = u2f_control_point.get();
      u2f_service_->AddMockCharacteristic(std::move(u2f_control_point));
    }

    {
      auto u2f_status = std::make_unique<NiceMockBluetoothGattCharacteristic>(
          u2f_service_, "u2f_status", BluetoothUUID(kFidoStatusUUID), is_local,
          BluetoothGattCharacteristic::PROPERTY_NOTIFY,
          BluetoothGattCharacteristic::PERMISSION_NONE);
      u2f_status_ = u2f_status.get();
      u2f_service_->AddMockCharacteristic(std::move(u2f_status));
    }

    {
      auto u2f_control_point_length =
          std::make_unique<NiceMockBluetoothGattCharacteristic>(
              u2f_service_, "u2f_control_point_length",
              BluetoothUUID(kFidoControlPointLengthUUID), is_local,
              BluetoothGattCharacteristic::PROPERTY_READ,
              BluetoothGattCharacteristic::PERMISSION_NONE);
      u2f_control_point_length_ = u2f_control_point_length.get();
      u2f_service_->AddMockCharacteristic(std::move(u2f_control_point_length));
    }

    {
      auto u2f_service_revision =
          std::make_unique<NiceMockBluetoothGattCharacteristic>(
              u2f_service_, "u2f_service_revision",
              BluetoothUUID(kFidoServiceRevisionUUID), is_local,
              BluetoothGattCharacteristic::PROPERTY_READ,
              BluetoothGattCharacteristic::PERMISSION_NONE);
      u2f_service_revision_ = u2f_service_revision.get();
      u2f_service_->AddMockCharacteristic(std::move(u2f_service_revision));
    }

    {
      auto u2f_service_revision_bitfield =
          std::make_unique<NiceMockBluetoothGattCharacteristic>(
              u2f_service_, "u2f_service_revision_bitfield",
              BluetoothUUID(kFidoServiceRevisionBitfieldUUID), is_local,
              BluetoothGattCharacteristic::PROPERTY_READ |
                  BluetoothGattCharacteristic::PROPERTY_WRITE,
              BluetoothGattCharacteristic::PERMISSION_NONE);
      u2f_service_revision_bitfield_ = u2f_service_revision_bitfield.get();
      u2f_service_->AddMockCharacteristic(
          std::move(u2f_service_revision_bitfield));
    }
  }

 private:
  base::test::ScopedTaskEnvironment scoped_task_environment_;

  scoped_refptr<MockBluetoothAdapter> adapter_ =
      base::MakeRefCounted<NiceMockBluetoothAdapter>();

  MockBluetoothDevice* u2f_device_;
  MockBluetoothGattService* u2f_service_;

  MockBluetoothGattCharacteristic* u2f_control_point_;
  MockBluetoothGattCharacteristic* u2f_status_;
  MockBluetoothGattCharacteristic* u2f_control_point_length_;
  MockBluetoothGattCharacteristic* u2f_service_revision_;
  MockBluetoothGattCharacteristic* u2f_service_revision_bitfield_;

  MockBluetoothGattConnection* connection_;
  MockBluetoothGattNotifySession* notify_session_;
};

TEST_F(FidoBleConnectionTest, Address) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  auto connect_do_nothing = [](bool) {};
  auto read_do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               base::BindRepeating(connect_do_nothing),
                               base::BindRepeating(read_do_nothing));
  connection.Connect();
  EXPECT_EQ(device_address, connection.address());
  AddU2Device(device_address);

  SimulateDeviceAddressChange(device_address, "new_device_address");
  EXPECT_EQ("new_device_address", connection.address());
}

TEST_F(FidoBleConnectionTest, DeviceNotPresent) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  auto do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_FALSE(result);
}

TEST_F(FidoBleConnectionTest, PreConnected) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);

  auto do_nothing = [](std::vector<uint8_t>) {};
  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(do_nothing));
  connection.Connect();
  EXPECT_TRUE(connection_status_callback.WaitForResult());
}

TEST_F(FidoBleConnectionTest, PostConnected) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  auto do_nothing = [](std::vector<uint8_t>) {};
  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_FALSE(result);

  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  NotifyDeviceAdded(device_address);
  EXPECT_TRUE(connection_status_callback.WaitForResult());
}

TEST_F(FidoBleConnectionTest, DeviceDisconnect) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;

  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto do_nothing = [](std::vector<uint8_t>) {};
  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_TRUE(result);

  SimulateDisconnect(device_address);
  result = connection_status_callback.WaitForResult();
  EXPECT_FALSE(result);
}

TEST_F(FidoBleConnectionTest, ReadStatusNotifications) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  TestReadCallback read_callback;

  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               read_callback.GetCallback());
  connection.Connect();
  EXPECT_TRUE(connection_status_callback.WaitForResult());

  std::vector<uint8_t> payload = ToByteVector("foo");
  NotifyStatusChanged(payload);
  EXPECT_EQ(payload, read_callback.WaitForResult());

  payload = ToByteVector("bar");
  NotifyStatusChanged(payload);
  EXPECT_EQ(payload, read_callback.WaitForResult());
}

TEST_F(FidoBleConnectionTest, ReadControlPointLength) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto read_do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(read_do_nothing));
  connection.Connect();
  EXPECT_TRUE(connection_status_callback.WaitForResult());

  TestReadControlPointLengthCallback length_callback;
  SetNextReadControlPointLengthReponse(false, {});
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(base::nullopt, length_callback.value());

  // The Control Point Length should consist of exactly two bytes, hence we
  // EXPECT_EQ(base::nullopt) for payloads of size 0, 1 and 3.
  SetNextReadControlPointLengthReponse(true, {});
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(base::nullopt, length_callback.value());

  SetNextReadControlPointLengthReponse(true, {0xAB});
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(base::nullopt, length_callback.value());

  SetNextReadControlPointLengthReponse(true, {0xAB, 0xCD});
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(0xABCD, *length_callback.value());

  SetNextReadControlPointLengthReponse(true, {0xAB, 0xCD, 0xEF});
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(base::nullopt, length_callback.value());
}

TEST_F(FidoBleConnectionTest, ReadServiceRevisions) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto read_do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(read_do_nothing));
  connection.Connect();
  EXPECT_TRUE(connection_status_callback.WaitForResult());

  TestReadServiceRevisionsCallback revisions_callback;
  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(), IsEmpty());

  SetNextReadServiceRevisionResponse(true, ToByteVector("bogus"));
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(), IsEmpty());

  SetNextReadServiceRevisionResponse(true, ToByteVector("1.0"));
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_0));

  SetNextReadServiceRevisionResponse(true, ToByteVector("1.1"));
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1));

  SetNextReadServiceRevisionResponse(true, ToByteVector("1.2"));
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_2));

  // Version 1.3 currently does not exist, so this should be treated as an
  // error.
  SetNextReadServiceRevisionResponse(true, ToByteVector("1.3"));
  SetNextReadServiceRevisionBitfieldResponse(false, {});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(), IsEmpty());

  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0x00});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(), IsEmpty());

  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0x80});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1));

  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0x40});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_2));

  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0xC0});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
                          FidoBleConnection::ServiceRevision::VERSION_1_2));

  // All bits except the first two should be ignored.
  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0xFF});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
                          FidoBleConnection::ServiceRevision::VERSION_1_2));

  // All bytes except the first one should be ignored.
  SetNextReadServiceRevisionResponse(false, {});
  SetNextReadServiceRevisionBitfieldResponse(true, {0xC0, 0xFF});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
                          FidoBleConnection::ServiceRevision::VERSION_1_2));

  // The combination of a service revision string and bitfield should be
  // supported as well.
  SetNextReadServiceRevisionResponse(true, ToByteVector("1.0"));
  SetNextReadServiceRevisionBitfieldResponse(true, {0xC0});
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(),
              ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_0,
                          FidoBleConnection::ServiceRevision::VERSION_1_1,
                          FidoBleConnection::ServiceRevision::VERSION_1_2));
}

TEST_F(FidoBleConnectionTest, WriteControlPoint) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto read_do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(read_do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_TRUE(result);

  TestWriteCallback write_callback;
  SetNextWriteControlPointResponse(false);
  connection.WriteControlPoint({}, write_callback.callback());
  result = write_callback.value();
  EXPECT_FALSE(result);

  SetNextWriteControlPointResponse(true);
  connection.WriteControlPoint({}, write_callback.callback());
  result = write_callback.value();
  EXPECT_TRUE(result);
}

TEST_F(FidoBleConnectionTest, WriteServiceRevision) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;
  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto read_do_nothing = [](std::vector<uint8_t>) {};

  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(read_do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_TRUE(result);

  // Expect that errors are properly propagated.
  TestWriteCallback write_callback;
  SetNextWriteServiceRevisionResponse(false);
  connection.WriteServiceRevision(
      FidoBleConnection::ServiceRevision::VERSION_1_1,
      write_callback.callback());
  result = write_callback.value();
  EXPECT_FALSE(result);

  // Expect a successful write of version 1.1.
  SetNextWriteServiceRevisionResponse(true);
  connection.WriteServiceRevision(
      FidoBleConnection::ServiceRevision::VERSION_1_1,
      write_callback.callback());
  result = write_callback.value();
  EXPECT_TRUE(result);

  // Expect a successful write of version 1.2.
  SetNextWriteServiceRevisionResponse(true);
  connection.WriteServiceRevision(
      FidoBleConnection::ServiceRevision::VERSION_1_2,
      write_callback.callback());
  result = write_callback.value();
  EXPECT_TRUE(result);

  // Writing version 1.0 to the bitfield is not intended, so this should fail.
  connection.WriteServiceRevision(
      FidoBleConnection::ServiceRevision::VERSION_1_0,
      write_callback.callback());
  result = write_callback.value();
  EXPECT_FALSE(result);
}

TEST_F(FidoBleConnectionTest, ReadsAndWriteFailWhenDisconnected) {
  const std::string device_address = BluetoothTest::kTestDeviceAddress1;
  TestConnectionStatusCallback connection_status_callback;

  AddU2Device(device_address);
  SetupConnectingU2fDevice(device_address);
  auto do_nothing = [](std::vector<uint8_t>) {};
  FidoBleConnection connection(device_address,
                               connection_status_callback.GetCallback(),
                               base::BindRepeating(do_nothing));
  connection.Connect();
  bool result = connection_status_callback.WaitForResult();
  EXPECT_TRUE(result);

  SimulateDisconnect(device_address);
  result = connection_status_callback.WaitForResult();
  EXPECT_FALSE(result);

  // Reads should always fail on a disconnected device.
  TestReadControlPointLengthCallback length_callback;
  connection.ReadControlPointLength(length_callback.callback());
  EXPECT_EQ(base::nullopt, length_callback.value());

  TestReadServiceRevisionsCallback revisions_callback;
  connection.ReadServiceRevisions(revisions_callback.callback());
  EXPECT_THAT(revisions_callback.value(), IsEmpty());

  // Writes should always fail on a disconnected device.
  TestWriteCallback write_callback;
  connection.WriteServiceRevision(
      FidoBleConnection::ServiceRevision::VERSION_1_1,
      write_callback.callback());
  result = write_callback.value();
  EXPECT_FALSE(result);

  connection.WriteControlPoint({}, write_callback.callback());
  result = write_callback.value();
  EXPECT_FALSE(result);
}

}  // namespace device