Implement BluetoothRemoteGattServiceWin and related unit tests

device/bluetooth/bluetooth_gatt_service_unittest.cc

 // Copyright 2015 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/bluetooth/bluetooth_gatt_service.h"
 
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.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"
 #endif
 
 namespace device {
 
-#if defined(OS_ANDROID) || defined(OS_MACOSX)
+#if defined(OS_ANDROID) || defined(OS_MACOSX) || defined(OS_WIN)
 class BluetoothGattServiceTest : public BluetoothTest {};
 #endif
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_WIN)
 TEST_F(BluetoothGattServiceTest, GetIdentifier) {
+  if (!PlatformSupportsLowEnergy()) {

[ortuno, 2016/02/19 17:33:05]

This only returns true for windows 8 and above. The win8 bot doesn't run
device_unittests so basically no bot would be able to run these tests.

[gogerald1, 2016/02/19 22:45:02]

Done.

[scheib, 2016/02/24 01:39:09]

It would have helped when replying 'Done' here to explain what was done to fix
it - since the code at this comment location didn't change and a reviewer won't
see in the patch diff what happened here.

Remove the skipping logic "if (!PlatformSupportsLowEnergy())" from the tests.
These InitWithFakeAdapter() tests should always run, even on OS versions that
are earlier than when the APIs are supported. The fakes should always work. I
made a mistake in earlier review not catching this -- please remove the skipping
logic from all tests using fake adapter. 

[gogerald1, 2016/02/25 23:19:17]

I've made PlatformSupportsLowEnergy always return true for test. Remove them
from Gatt service unit tests

+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
   InitWithFakeAdapter();
   StartLowEnergyDiscoverySession();
   // 2 devices to verify unique IDs across them.
   BluetoothDevice* device1 = DiscoverLowEnergyDevice(3);
   BluetoothDevice* device2 = DiscoverLowEnergyDevice(4);
   device1->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                 GetConnectErrorCallback(Call::NOT_EXPECTED));
   device2->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                 GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device1);
@@ skipping 14 matching lines @@
   // All IDs are unique, even though they have the same UUID.
   EXPECT_NE(service1->GetIdentifier(), service2->GetIdentifier());
   EXPECT_NE(service1->GetIdentifier(), service3->GetIdentifier());
   EXPECT_NE(service1->GetIdentifier(), service4->GetIdentifier());
 
   EXPECT_NE(service2->GetIdentifier(), service3->GetIdentifier());
   EXPECT_NE(service2->GetIdentifier(), service4->GetIdentifier());
 
   EXPECT_NE(service3->GetIdentifier(), service4->GetIdentifier());
 }
-#endif  // defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID) || defined(OS_WIN)
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_WIN)
 TEST_F(BluetoothGattServiceTest, GetUUID) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
   InitWithFakeAdapter();
   StartLowEnergyDiscoverySession();
   BluetoothDevice* device = DiscoverLowEnergyDevice(3);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
 
   // Create multiple instances with the same UUID.
   BluetoothUUID uuid("00000000-0000-1000-8000-00805f9b34fb");
   std::vector<std::string> services;
   services.push_back(uuid.canonical_value());
   services.push_back(uuid.canonical_value());
   SimulateGattServicesDiscovered(device, services);
 
   // Each has the same UUID.
   EXPECT_EQ(uuid, device->GetGattServices()[0]->GetUUID());
   EXPECT_EQ(uuid, device->GetGattServices()[1]->GetUUID());
 }
-#endif  // defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID) || defined(OS_WIN)
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_WIN)
 TEST_F(BluetoothGattServiceTest, GetCharacteristics_FindNone) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
   InitWithFakeAdapter();
   StartLowEnergyDiscoverySession();
   BluetoothDevice* device = DiscoverLowEnergyDevice(3);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
 
   // Simulate a service, with no Characteristics:
   std::vector<std::string> services;
   services.push_back("00000000-0000-1000-8000-00805f9b34fb");
   SimulateGattServicesDiscovered(device, services);
   BluetoothGattService* service = device->GetGattServices()[0];
 
   EXPECT_EQ(0u, service->GetCharacteristics().size());
 }
-#endif  // defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID) || defined(OS_WIN)
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_WIN)
 TEST_F(BluetoothGattServiceTest, GetCharacteristics_and_GetCharacteristic) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
   InitWithFakeAdapter();
   StartLowEnergyDiscoverySession();
   BluetoothDevice* device = DiscoverLowEnergyDevice(3);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
 
   // Simulate a service, with several Characteristics:
   std::vector<std::string> services;
   services.push_back("00000000-0000-1000-8000-00805f9b34fb");
@@ skipping 24 matching lines @@
   EXPECT_EQ(char_uuid3, service->GetCharacteristic(char_id3)->GetUUID());
   EXPECT_EQ(char_uuid4, service->GetCharacteristic(char_id4)->GetUUID());
 
   // GetCharacteristics & GetCharacteristic return the same object for the same
   // ID:
   EXPECT_EQ(service->GetCharacteristics()[0],
             service->GetCharacteristic(char_id1));
   EXPECT_EQ(service->GetCharacteristic(char_id1),
             service->GetCharacteristic(char_id1));
 }
-#endif  // defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID) || defined(OS_WIN)
+
+#if defined(OS_WIN)
+TEST_F(BluetoothGattServiceTest, GetCharacteristic_CharacteristicRemoved) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
+  InitWithFakeAdapter();
+  StartLowEnergyDiscoverySession();
+  BluetoothDevice* device = DiscoverLowEnergyDevice(3);
+  device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
+                               GetConnectErrorCallback(Call::NOT_EXPECTED));
+  SimulateGattConnection(device);
+
+  // Simulate a service, with several Characteristics:
+  std::vector<std::string> services;
+  services.push_back("00000000-0000-1000-8000-00805f9b34fb");
+  SimulateGattServicesDiscovered(device, services);
+  BluetoothGattService* service = device->GetGattServices()[0];
+  std::string characteristic_uuid1 = "11111111-0000-1000-8000-00805f9b34fb";
+  std::string characteristic_uuid2 = "22222222-0000-1000-8000-00805f9b34fb";
+  std::string characteristic_uuid3 = characteristic_uuid2;  // Duplicate UUID.
+  std::string characteristic_uuid4 = "33333333-0000-1000-8000-00805f9b34fb";
+  SimulateGattCharacteristic(service, characteristic_uuid1, /* properties */ 0);
+  SimulateGattCharacteristic(service, characteristic_uuid2, /* properties */ 0);
+  SimulateGattCharacteristic(service, characteristic_uuid3, /* properties */ 0);
+  SimulateGattCharacteristic(service, characteristic_uuid4, /* properties */ 0);
+
+  // Simulate remove of characteristics one by one.
+  EXPECT_EQ(4u, service->GetCharacteristics().size());
+  std::string removed_char = service->GetCharacteristics()[0]->GetIdentifier();
+  SimulateGattCharacteristicRemove(service,
+                                   service->GetCharacteristic(removed_char));
+  EXPECT_FALSE(service->GetCharacteristic(removed_char));
+  EXPECT_EQ(3u, service->GetCharacteristics().size());
+  removed_char = service->GetCharacteristics()[0]->GetIdentifier();
+  SimulateGattCharacteristicRemove(service,
+                                   service->GetCharacteristic(removed_char));
+  EXPECT_FALSE(service->GetCharacteristic(removed_char));
+  EXPECT_EQ(2u, service->GetCharacteristics().size());
+  removed_char = service->GetCharacteristics()[0]->GetIdentifier();
+  SimulateGattCharacteristicRemove(service,
+                                   service->GetCharacteristic(removed_char));
+  EXPECT_FALSE(service->GetCharacteristic(removed_char));
+  EXPECT_EQ(1u, service->GetCharacteristics().size());
+  removed_char = service->GetCharacteristics()[0]->GetIdentifier();
+  SimulateGattCharacteristicRemove(service,
+                                   service->GetCharacteristic(removed_char));
+  EXPECT_FALSE(service->GetCharacteristic(removed_char));
+  EXPECT_EQ(0u, service->GetCharacteristics().size());
+}
+#endif  // defined(OS_WIN)
+
+#if defined(OS_WIN)
+TEST_F(BluetoothGattServiceTest, GetIncludedServices) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
+  InitWithFakeAdapter();
+  StartLowEnergyDiscoverySession();
+  BluetoothDevice* device = DiscoverLowEnergyDevice(3);
+  device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
+                               GetConnectErrorCallback(Call::NOT_EXPECTED));
+  SimulateGattConnection(device);
+
+  // Simulate a service, with several included services:
+  std::vector<std::string> services;
+  services.push_back("00000000-0000-1000-8000-00805f9b34fb");
+  SimulateGattServicesDiscovered(device, services);
+  BluetoothGattService* service = device->GetGattServices()[0];
+  std::vector<std::string> included_service_uuids;
+  included_service_uuids.push_back("11111111-0000-1000-8000-00805f9b34fb");
+  included_service_uuids.push_back("22222222-0000-1000-8000-00805f9b34fb");
+  included_service_uuids.push_back(
+      "22222222-0000-1000-8000-00805f9b34fb");  // Duplicate UUID.
+  included_service_uuids.push_back("33333333-0000-1000-8000-00805f9b34fb");
+  SimulateIncludedGattServicesDiscovered(service, included_service_uuids);
+
+  // Verify that GetIncludedServices can retrieve included services.
+  EXPECT_EQ(4u, service->GetIncludedServices().size());
+  std::vector<BluetoothGattService*> f_included_services =
+      service->GetIncludedServices();
+  for (auto i_s : f_included_services) {
+    EXPECT_FALSE(i_s->IsPrimary());
+  }
+  std::vector<std::string> f_included_service_uuids;
+  f_included_service_uuids.push_back(f_included_services[0]->GetUUID().value());
+  f_included_service_uuids.push_back(f_included_services[1]->GetUUID().value());
+  f_included_service_uuids.push_back(f_included_services[2]->GetUUID().value());
+  f_included_service_uuids.push_back(f_included_services[3]->GetUUID().value());
+  std::sort(f_included_service_uuids.begin(), f_included_service_uuids.end());
+  std::sort(included_service_uuids.begin(), included_service_uuids.end());
+  for (std::size_t i = 0; i < 4; i++) {
+    EXPECT_EQ(f_included_service_uuids[i], included_service_uuids[i]);
+  }
+}
+#endif  // defined(OS_WIN)
+
+#if defined(OS_WIN)
+TEST_F(BluetoothGattServiceTest, SimulateGattServiceRemove) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
+  InitWithFakeAdapter();
+  StartLowEnergyDiscoverySession();
+  BluetoothDevice* device = DiscoverLowEnergyDevice(3);
+  device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
+                               GetConnectErrorCallback(Call::NOT_EXPECTED));
+  SimulateGattConnection(device);
+
+  // Simulate two primary GATT services, with several included services:
+  std::vector<std::string> services;
+  services.push_back("00000000-0000-1000-8000-00805f9b34fb");
+  services.push_back("01010101-0101-1000-8000-00805f9b34fb");
+  SimulateGattServicesDiscovered(device, services);
+  EXPECT_EQ(2u, device->GetGattServices().size());
+  BluetoothGattService* service1 = device->GetGattServices()[0];
+  BluetoothGattService* service2 = device->GetGattServices()[1];
+  std::vector<std::string> included_service_uuids;
+  included_service_uuids.push_back("11111111-0000-1000-8000-00805f9b34fb");
+  included_service_uuids.push_back("22222222-0000-1000-8000-00805f9b34fb");
+  included_service_uuids.push_back(
+      "22222222-0000-1000-8000-00805f9b34fb");  // Duplicate UUID.
+  included_service_uuids.push_back("33333333-0000-1000-8000-00805f9b34fb");
+  SimulateIncludedGattServicesDiscovered(service1, included_service_uuids);
+  SimulateIncludedGattServicesDiscovered(service2, included_service_uuids);
+  EXPECT_EQ(4u, service1->GetIncludedServices().size());
+  EXPECT_EQ(4u, service2->GetIncludedServices().size());
+
+  // Simulate remove of an included service.
+  SimulateGattServiceRemoved(service1->GetIncludedServices()[0]);
+  EXPECT_EQ(3u, service1->GetIncludedServices().size());
+  SimulateGattServiceRemoved(service2->GetIncludedServices()[0]);
+  EXPECT_EQ(3u, service2->GetIncludedServices().size());
+
+  // Simulate remove of a primary service.
+  std::string removed_service = service1->GetIdentifier();
+  SimulateGattServiceRemoved(device->GetGattService(removed_service));
+  EXPECT_EQ(1u, device->GetGattServices().size());
+  EXPECT_FALSE(device->GetGattService(removed_service));
+}
+#endif  // defined(OS_WIN)
 
 }  // namespace device