WIP: DO NOT SUBMIT

device/bluetooth/bluetooth_experimental_chromeos_unittest.cc

+// Copyright (c) 2013 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/command_line.h"
+#include "base/message_loop.h"
+#include "base/utf_string_conversions.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/fake_bluetooth_adapter_client.h"
+#include "chromeos/dbus/fake_bluetooth_device_client.h"
+#include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
+#include "dbus/object_path.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_experimental_chromeos.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
+#include "device/bluetooth/bluetooth_device_experimental_chromeos.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using device::BluetoothAdapter;
+using device::BluetoothAdapterFactory;
+using device::BluetoothDevice;
+
+namespace chromeos {
+
+class BluetoothExperimentalChromeOSTest : public testing::Test {
+ public:
+  virtual void SetUp() {
+    if (!CommandLine::ForCurrentProcess()->HasSwitch(
+            chromeos::switches::kEnableExperimentalBluetooth))
+      CommandLine::ForCurrentProcess()->AppendSwitch(
+          chromeos::switches::kEnableExperimentalBluetooth);
+
+    mock_dbus_thread_manager_ =
+        new MockDBusThreadManagerWithoutGMock();
+    DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager_);
+
+    fake_bluetooth_adapter_client_ =
+      mock_dbus_thread_manager_->fake_bluetooth_adapter_client();
+    fake_bluetooth_device_client_ =
+      mock_dbus_thread_manager_->fake_bluetooth_device_client();
+
+    callback_count_ = 0;
+    error_callback_count_ = 0;
+  }
+
+  virtual void TearDown() {
+    adapter_ = NULL;
+    DBusThreadManager::Shutdown();
+  }
+
+  // Generic callbacks
+  void Callback() {
+    ++callback_count_;
+  }
+
+  void ErrorCallback() {
+    ++error_callback_count_;
+  }
+
+ protected:
+  // Call to fill the adapter_ member with a BluetoothAdapter instance.
+  void GetAdapter() {
+    BluetoothAdapterFactory::GetAdapter(
+        base::Bind(&BluetoothExperimentalChromeOSTest::SetAdapter,
+                   base::Unretained(this)));
+    ASSERT_TRUE(adapter_ != NULL);
+    ASSERT_TRUE(adapter_->IsInitialized());
+  }
+
+  void SetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
+    adapter_ = adapter;
+  }
+
+  FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_;
+  FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
+  MockDBusThreadManagerWithoutGMock* mock_dbus_thread_manager_;
+  scoped_refptr<BluetoothAdapter> adapter_;
+
+  int callback_count_;
+  int error_callback_count_;
+};
+
+class TestObserver : public BluetoothAdapter::Observer {
+ public:
+  TestObserver(scoped_refptr<BluetoothAdapter> adapter)
+      : present_changed_count_(0),
+        powered_changed_count_(0),
+        discovering_changed_count_(0),
+        last_present_(false),
+        last_powered_(false),
+        last_discovering_(false),
+        device_added_count_(0),
+        device_changed_count_(0),
+        device_removed_count_(0),
+        last_device_(NULL),
+        adapter_(adapter) {
+  }
+  virtual ~TestObserver() {}
+
+  virtual void AdapterPresentChanged(BluetoothAdapter* adapter,
+                                     bool present) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++present_changed_count_;
+    last_present_ = present;
+  }
+
+  virtual void AdapterPoweredChanged(BluetoothAdapter* adapter,
+                                     bool powered) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++powered_changed_count_;
+    last_powered_ = powered;
+  }
+
+  virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter,
+                                         bool discovering) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++discovering_changed_count_;
+    last_discovering_ = discovering;
+
+    QuitMessageLoop();
+  }
+
+  virtual void DeviceAdded(BluetoothAdapter* adapter,
+                           BluetoothDevice* device) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++device_added_count_;
+    last_device_ = device;
+    last_device_address_ = device->GetAddress();
+
+    QuitMessageLoop();
+  }
+
+  virtual void DeviceChanged(BluetoothAdapter* adapter,
+                             BluetoothDevice* device) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++device_changed_count_;
+    last_device_ = device;
+    last_device_address_ = device->GetAddress();
+
+    QuitMessageLoop();
+  }
+
+  virtual void DeviceRemoved(BluetoothAdapter* adapter,
+                             BluetoothDevice* device) OVERRIDE {
+    EXPECT_EQ(adapter_, adapter);
+
+    ++device_removed_count_;
+    // Can't save device, it may be freed
+    last_device_address_ = device->GetAddress();
+
+    QuitMessageLoop();
+  }
+
+  int present_changed_count_;
+  int powered_changed_count_;
+  int discovering_changed_count_;
+  bool last_present_;
+  bool last_powered_;
+  bool last_discovering_;
+  int device_added_count_;
+  int device_changed_count_;
+  int device_removed_count_;
+  BluetoothDevice* last_device_;
+  std::string last_device_address_;
+
+ private:
+  // Some tests use a message loop since background processing is simulated;
+  // break out of those loops.
+  void QuitMessageLoop() {
+    if (MessageLoop::current() && MessageLoop::current()->is_running())
+      MessageLoop::current()->Quit();
+  }
+
+  scoped_refptr<BluetoothAdapter> adapter_;
+};
+
+TEST_F(BluetoothExperimentalChromeOSTest, AlreadyPresent) {
+  GetAdapter();
+
+  // This verifies that the class gets the list of adapters when created;
+  // and initializes with an existing adapter if there is one.
+  EXPECT_TRUE(adapter_->IsPresent());
+  EXPECT_FALSE(adapter_->IsPowered());
+  EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterAddress,
+            adapter_->GetAddress());
+  EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterName, adapter_->GetName());
+  EXPECT_FALSE(adapter_->IsDiscovering());
+
+  // There should be a device
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  EXPECT_EQ(1U, devices.size());
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, BecomePresent) {
+  fake_bluetooth_adapter_client_->SetVisible(false);
+  GetAdapter();
+  ASSERT_FALSE(adapter_->IsPresent());
+
+  // Install an observer; expect the AdapterPresentChanged to be called
+  // with true, and IsPresent() to return true.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  fake_bluetooth_adapter_client_->SetVisible(true);
+
+  EXPECT_EQ(1, observer.present_changed_count_);
+  EXPECT_TRUE(observer.last_present_);
+
+  EXPECT_TRUE(adapter_->IsPresent());
+
+  // We should have had a device announced.
+  EXPECT_EQ(1, observer.device_added_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            observer.last_device_address_);
+
+  // Other callbacks shouldn't be called if the values are false.
+  EXPECT_EQ(0, observer.powered_changed_count_);
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+  EXPECT_FALSE(adapter_->IsPowered());
+  EXPECT_FALSE(adapter_->IsDiscovering());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, BecomeNotPresent) {
+  GetAdapter();
+  ASSERT_TRUE(adapter_->IsPresent());
+
+  // Install an observer; expect the AdapterPresentChanged to be called
+  // with false, and IsPresent() to return false.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  fake_bluetooth_adapter_client_->SetVisible(false);
+
+  EXPECT_EQ(1, observer.present_changed_count_);
+  EXPECT_FALSE(observer.last_present_);
+
+  EXPECT_FALSE(adapter_->IsPresent());
+
+  // We should have had a device removed.
+  EXPECT_EQ(1, observer.device_removed_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            observer.last_device_address_);
+
+  // Other callbacks shouldn't be called since the values are false.
+  EXPECT_EQ(0, observer.powered_changed_count_);
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+  EXPECT_FALSE(adapter_->IsPowered());
+  EXPECT_FALSE(adapter_->IsDiscovering());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, SecondAdapter) {
+  GetAdapter();
+  ASSERT_TRUE(adapter_->IsPresent());
+
+  // Install an observer, then add a second adapter. Nothing should change,
+  // we ignore the second adapter.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  fake_bluetooth_adapter_client_->SetSecondVisible(true);
+
+  EXPECT_EQ(0, observer.present_changed_count_);
+
+  EXPECT_TRUE(adapter_->IsPresent());
+  EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterAddress,
+            adapter_->GetAddress());
+
+  // Try removing the first adapter, we should now act as if the adapter
+  // is no longer present rather than fall back to the second.
+  fake_bluetooth_adapter_client_->SetVisible(false);
+
+  EXPECT_EQ(1, observer.present_changed_count_);
+  EXPECT_FALSE(observer.last_present_);
+
+  EXPECT_FALSE(adapter_->IsPresent());
+
+  // We should have had a device removed.
+  EXPECT_EQ(1, observer.device_removed_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            observer.last_device_address_);
+
+  // Other callbacks shouldn't be called since the values are false.
+  EXPECT_EQ(0, observer.powered_changed_count_);
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+  EXPECT_FALSE(adapter_->IsPowered());
+  EXPECT_FALSE(adapter_->IsDiscovering());
+
+  observer.device_removed_count_ = 0;
+
+  // Removing the second adapter shouldn't set anything either.
+  fake_bluetooth_adapter_client_->SetSecondVisible(false);
+
+  EXPECT_EQ(0, observer.device_removed_count_);
+  EXPECT_EQ(0, observer.powered_changed_count_);
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, BecomePowered) {
+  GetAdapter();
+  ASSERT_FALSE(adapter_->IsPowered());
+
+  // Install an observer; expect the AdapterPoweredChanged to be called
+  // with true, and IsPowered() to return true.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+
+  EXPECT_EQ(1, observer.powered_changed_count_);
+  EXPECT_TRUE(observer.last_powered_);
+
+  EXPECT_TRUE(adapter_->IsPowered());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, BecomeNotPowered) {
+  GetAdapter();
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  ASSERT_TRUE(adapter_->IsPowered());
+
+  // Install an observer; expect the AdapterPoweredChanged to be called
+  // with false, and IsPowered() to return false.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  adapter_->SetPowered(
+      false,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+
+  EXPECT_EQ(1, observer.powered_changed_count_);
+  EXPECT_FALSE(observer.last_powered_);
+
+  EXPECT_FALSE(adapter_->IsPowered());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, StopDiscovery) {
+  base::MessageLoop message_loop(MessageLoop::TYPE_DEFAULT);
+
+  GetAdapter();
+
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  adapter_->StartDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  ASSERT_TRUE(adapter_->IsPowered());
+  ASSERT_TRUE(adapter_->IsDiscovering());
+
+  // Install an observer; aside from the callback, expect the
+  // AdapterDiscoveringChanged method to be called and no longer to be
+  // discovering,
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  adapter_->StopDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+
+  EXPECT_EQ(1, observer.discovering_changed_count_);
+  EXPECT_FALSE(observer.last_discovering_);
+
+  EXPECT_FALSE(adapter_->IsDiscovering());
+
+  message_loop.RunUntilIdle();
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, StopDiscoveryAfterTwoStarts) {
+  base::MessageLoop message_loop(MessageLoop::TYPE_DEFAULT);
+
+  GetAdapter();
+
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  adapter_->StartDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  ASSERT_TRUE(adapter_->IsPowered());
+  ASSERT_TRUE(adapter_->IsDiscovering());
+
+  // Install an observer and start discovering again; only the callback
+  // should be called since we were already discovering to begin with.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  adapter_->StartDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+
+  // Stop discovering; only the callback should be called since we're still
+  // discovering. The adapter should be still discovering.
+  adapter_->StopDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  EXPECT_EQ(0, observer.discovering_changed_count_);
+
+  EXPECT_TRUE(adapter_->IsDiscovering());
+
+  // Stop discovering one more time; aside from the callback, expect the
+  // AdapterDiscoveringChanged method to be called and no longer to be
+  // discovering,
+  adapter_->StopDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+
+  EXPECT_EQ(1, observer.discovering_changed_count_);
+  EXPECT_FALSE(observer.last_discovering_);
+
+  EXPECT_FALSE(adapter_->IsDiscovering());
+
+  message_loop.RunUntilIdle();
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, Discovery) {
+  // Test a simulated discovery session.
+  base::MessageLoop message_loop(MessageLoop::TYPE_DEFAULT);
+
+  fake_bluetooth_device_client_->SetDiscoverySimulationIntervalMs(10);
+  GetAdapter();
+
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  adapter_->StartDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  ASSERT_TRUE(adapter_->IsPowered());
+  ASSERT_TRUE(adapter_->IsDiscovering());
+
+  // First device to appear should be an Apple Mouse.
+  message_loop.Run();
+
+  EXPECT_EQ(1, observer.device_added_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kAppleMouseAddress,
+            observer.last_device_address_);
+
+  // Next we should get another two devices...
+  message_loop.Run();
+  EXPECT_EQ(3, observer.device_added_count_);
+
+  // Okay, let's run forward until a device is actually removed...
+  while (!observer.device_removed_count_)
+    message_loop.Run();
+
+  EXPECT_EQ(1, observer.device_removed_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kVanishingDeviceAddress,
+            observer.last_device_address_);
+
+  message_loop.RunUntilIdle();
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, PoweredAndDiscovering) {
+  base::MessageLoop message_loop(MessageLoop::TYPE_DEFAULT);
+
+  GetAdapter();
+  adapter_->SetPowered(
+      true,
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  adapter_->StartDiscovering(
+      base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  callback_count_ = 0;
+
+  // Stop the timers that the simulation uses
+  fake_bluetooth_device_client_->EndDiscoverySimulation(
+      FakeBluetoothAdapterClient::kAdapterPath);
+  message_loop.RunUntilIdle();
+
+  ASSERT_TRUE(adapter_->IsPowered());
+  ASSERT_TRUE(adapter_->IsDiscovering());
+
+  fake_bluetooth_adapter_client_->SetVisible(false);
+  ASSERT_FALSE(adapter_->IsPresent());
+
+  // Install an observer; expect the AdapterPresentChanged,
+  // AdapterPoweredChanged and AdapterDiscoveringChanged methods to be called
+  // with true, and IsPresent(), IsPowered() and IsDiscovering() to all
+  // return true.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  fake_bluetooth_adapter_client_->SetVisible(true);
+
+  EXPECT_EQ(1, observer.present_changed_count_);
+  EXPECT_TRUE(observer.last_present_);
+  EXPECT_TRUE(adapter_->IsPresent());
+
+  EXPECT_EQ(1, observer.powered_changed_count_);
+  EXPECT_TRUE(observer.last_powered_);
+  EXPECT_TRUE(adapter_->IsPowered());
+
+  EXPECT_EQ(1, observer.discovering_changed_count_);
+  EXPECT_TRUE(observer.last_discovering_);
+  EXPECT_TRUE(adapter_->IsDiscovering());
+
+  observer.present_changed_count_ = 0;
+  observer.powered_changed_count_ = 0;
+  observer.discovering_changed_count_ = 0;
+
+  // Now mark the adapter not present again. Expect the methods to be called
+  // again, to reset the properties back to false
+  fake_bluetooth_adapter_client_->SetVisible(false);
+
+  EXPECT_EQ(1, observer.present_changed_count_);
+  EXPECT_FALSE(observer.last_present_);
+  EXPECT_FALSE(adapter_->IsPresent());
+
+  EXPECT_EQ(1, observer.powered_changed_count_);
+  EXPECT_FALSE(observer.last_powered_);
+  EXPECT_FALSE(adapter_->IsPowered());
+
+  EXPECT_EQ(1, observer.discovering_changed_count_);
+  EXPECT_FALSE(observer.last_discovering_);
+  EXPECT_FALSE(adapter_->IsDiscovering());
+}
+
+// trusted property set during pair
+// paired property announced via change
+//
+// connected property set during connect
+
+TEST_F(BluetoothExperimentalChromeOSTest, DeviceProperties) {
+  GetAdapter();
+
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+
+  // Verify the other device properties.
+  EXPECT_EQ(UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName),
+            devices[0]->GetName());
+  EXPECT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType());
+  EXPECT_TRUE(devices[0]->IsPaired());
+  EXPECT_FALSE(devices[0]->IsConnected());
+  EXPECT_FALSE(devices[0]->IsConnectable());
+  EXPECT_FALSE(devices[0]->IsConnecting());
+
+  BluetoothDevice::ServiceList uuids = devices[0]->GetServices();
+  ASSERT_EQ(2U, uuids.size());
+  EXPECT_EQ(uuids[0], "00001800-0000-1000-8000-00805f9b34fb");
+  EXPECT_EQ(uuids[1], "00001801-0000-1000-8000-00805f9b34fb");
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, DeviceClassChanged) {
+  // Simulate a change of class of a device, as sometimes occurs
+  // during discovery.
+  GetAdapter();
+
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+  ASSERT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType());
+
+  // Install an observer; expect the DeviceChanged method to be called when
+  // we change the class of the device.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          FakeBluetoothDeviceClient::kPairedDevicePath);
+
+  properties->bluetooth_class.ReplaceValue(0x002580);
+  properties->NotifyPropertyChanged(properties->bluetooth_class.name());
+
+  EXPECT_EQ(1, observer.device_changed_count_);
+  EXPECT_EQ(devices[0], observer.last_device_);
+
+  EXPECT_EQ(BluetoothDevice::DEVICE_MOUSE, devices[0]->GetDeviceType());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, DeviceNameChanged) {
+  // Simulate a change of name of a device.
+  GetAdapter();
+
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+  ASSERT_EQ(UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName),
+            devices[0]->GetName());
+
+  // Install an observer; expect the DeviceChanged method to be called when
+  // we change the alias of the device.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          FakeBluetoothDeviceClient::kPairedDevicePath);
+
+  static const std::string new_name("New Device Name");
+  properties->alias.ReplaceValue(new_name);
+  properties->NotifyPropertyChanged(properties->alias.name());
+
+  EXPECT_EQ(1, observer.device_changed_count_);
+  EXPECT_EQ(devices[0], observer.last_device_);
+
+  EXPECT_EQ(UTF8ToUTF16(new_name), devices[0]->GetName());
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, DeviceUuidsChanged) {
+  // Simulate a change of advertised services of a device.
+  GetAdapter();
+
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+
+  BluetoothDevice::ServiceList uuids = devices[0]->GetServices();
+  ASSERT_EQ(2U, uuids.size());
+  ASSERT_EQ(uuids[0], "00001800-0000-1000-8000-00805f9b34fb");
+  ASSERT_EQ(uuids[1], "00001801-0000-1000-8000-00805f9b34fb");
+
+  // Install an observer; expect the DeviceChanged method to be called when
+  // we change the class of the device.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  FakeBluetoothDeviceClient::Properties* properties =
+      fake_bluetooth_device_client_->GetProperties(
+          FakeBluetoothDeviceClient::kPairedDevicePath);
+
+  uuids.push_back("0000110c-0000-1000-8000-00805f9b34fb");
+  uuids.push_back("0000110e-0000-1000-8000-00805f9b34fb");
+  uuids.push_back("0000110a-0000-1000-8000-00805f9b34fb");
+
+  properties->uuids.ReplaceValue(uuids);
+  properties->NotifyPropertyChanged(properties->uuids.name());
+
+  EXPECT_EQ(1, observer.device_changed_count_);
+  EXPECT_EQ(devices[0], observer.last_device_);
+
+  // Fetching the value should give the new one.
+  uuids = devices[0]->GetServices();
+  ASSERT_EQ(5U, uuids.size());
+  EXPECT_EQ(uuids[0], "00001800-0000-1000-8000-00805f9b34fb");
+  EXPECT_EQ(uuids[1], "00001801-0000-1000-8000-00805f9b34fb");
+  EXPECT_EQ(uuids[2], "0000110c-0000-1000-8000-00805f9b34fb");
+  EXPECT_EQ(uuids[3], "0000110e-0000-1000-8000-00805f9b34fb");
+  EXPECT_EQ(uuids[4], "0000110a-0000-1000-8000-00805f9b34fb");
+}
+
+TEST_F(BluetoothExperimentalChromeOSTest, ForgetDevice) {
+  GetAdapter();
+
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+            devices[0]->GetAddress());
+
+  std::string address = devices[0]->GetAddress();
+
+  // Install an observer; expect the DeviceRemoved method to be called
+  // with the device we remove.
+  TestObserver observer(adapter_);
+  adapter_->AddObserver(&observer);
+
+  devices[0]->Forget(
+      base::Bind(&BluetoothExperimentalChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, error_callback_count_);
+
+  EXPECT_EQ(1, observer.device_removed_count_);
+  EXPECT_EQ(address, observer.last_device_address_);
+
+  // GetDevices shouldn't return the device either.
+  devices = adapter_->GetDevices();
+  ASSERT_EQ(0U, devices.size());
+}
+
+}  // namespace chromeos