Read characteristic implementation on macOS

device/bluetooth/test/bluetooth_test_mac.mm

 // 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/test/bluetooth_test_mac.h"
 
 #include <stdint.h>
 
 #include "base/mac/foundation_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
+#include "device/bluetooth/bluetooth_device_mac.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_mac.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_mac.h"
 #include "device/bluetooth/test/mock_bluetooth_cbcharacteristic_mac.h"
 #include "device/bluetooth/test/mock_bluetooth_cbperipheral_mac.h"
 #include "device/bluetooth/test/mock_bluetooth_cbservice_mac.h"
 #include "device/bluetooth/test/mock_bluetooth_central_manager_mac.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "third_party/ocmock/OCMock/OCMock.h"
 
 #import <CoreBluetooth/CoreBluetooth.h>
@@ skipping 50 matching lines @@
 }
 
 }  // namespace
 
 // UUID1 hashes to kTestDeviceAddress1, and UUID2 to kTestDeviceAddress2.
 const std::string BluetoothTestMac::kTestPeripheralUUID1 =
     "34045B00-0000-0000-0000-000000000000";
 const std::string BluetoothTestMac::kTestPeripheralUUID2 =
     "EC1B8F00-0000-0000-0000-000000000000";
 
-BluetoothTestMac::BluetoothTestMac() {}
+BluetoothTestMac::BluetoothTestMac() : BluetoothTestBase() {}
 
 BluetoothTestMac::~BluetoothTestMac() {}
 
 void BluetoothTestMac::SetUp() {}
 
 bool BluetoothTestMac::PlatformSupportsLowEnergy() {
   return BluetoothAdapterMac::IsLowEnergyAvailable();
 }
 
 void BluetoothTestMac::InitWithDefaultAdapter() {
@@ skipping 188 matching lines @@
   MockCBService* service_mock = ObjCCast<MockCBService>(cb_service);
   CBUUID* cb_uuid = [CBUUID UUIDWithString:@(uuid.c_str())];
   [service_mock addCharacteristicWithUUID:cb_uuid properties:properties];
   MockCBPeripheral* peripheral_mock = GetMockCBPeripheral(service);
   [peripheral_mock didModifyServices:@[]];
   // After -[MockCBPeripheral didModifyServices:], BluetoothLowEnergyDeviceMac
   // is expected to call -[CBPeripheral discoverServices:]
   DidDiscoverServices(peripheral_mock);
 }
 
+void BluetoothTestMac::SimulateGattCharacteristicRead(
+    BluetoothRemoteGattCharacteristic* characteristic,
+    const std::vector<uint8_t>& value) {
+  MockCBCharacteristic* characteristic_mock =
+      GetCBMockCharacteristic(characteristic);
+  scoped_nsobject<NSData> data(
+      [[NSData alloc] initWithBytes:value.data() length:value.size()]);
+  [characteristic_mock simulateReadWithValue:data error:nil];
+}
+
+void BluetoothTestMac::SimulateGattCharacteristicReadError(
+    BluetoothRemoteGattCharacteristic* characteristic,
+    BluetoothRemoteGattService::GattErrorCode error_code) {
+  MockCBCharacteristic* characteristic_mock =
+      GetCBMockCharacteristic(characteristic);
+  NSError* error = BluetoothDeviceMac::GetNSErrorFromGattErrorCode(error_code);
+  [characteristic_mock simulateReadWithValue:nil error:error];
+}
+
 void BluetoothTestMac::SimulateGattCharacteristicRemoved(
     BluetoothRemoteGattService* service,
     BluetoothRemoteGattCharacteristic* characteristic) {
   MockCBPeripheral* peripheral_mock = GetMockCBPeripheral(service);
   BluetoothRemoteGattServiceMac* mac_gatt_service =
       static_cast<BluetoothRemoteGattServiceMac*>(service);
   CBService* cb_service = mac_gatt_service->GetService();
   MockCBService* service_mock = ObjCCast<MockCBService>(cb_service);
   BluetoothRemoteGattCharacteristicMac* characteristic_mac =
       static_cast<BluetoothRemoteGattCharacteristicMac*>(characteristic);
@@ skipping 10 matching lines @@
 }
 
 void BluetoothTestMac::OnFakeBluetoothGattDisconnect() {
   gatt_disconnection_attempts_++;
 }
 
 void BluetoothTestMac::OnFakeBluetoothServiceDiscovery() {
   gatt_discovery_attempts_++;
 }
 
+void BluetoothTest::OnFakeBluetoothCharacteristicReadValue() {
+  gatt_read_characteristic_attempts_++;
+}
+
 MockCBPeripheral* BluetoothTestMac::GetMockCBPeripheral(
     BluetoothRemoteGattService* service) const {
   BluetoothDevice* device = service->GetDevice();
   BluetoothLowEnergyDeviceMac* device_mac =
       static_cast<BluetoothLowEnergyDeviceMac*>(device);
   CBPeripheral* cb_peripheral = device_mac->GetPeripheral();
   return ObjCCast<MockCBPeripheral>(cb_peripheral);
 }
 
+MockCBCharacteristic* BluetoothTest::GetCBMockCharacteristic(
+    device::BluetoothRemoteGattCharacteristic* characteristic) const {
+  device::BluetoothRemoteGattCharacteristicMac* mac_gatt_characteristic =
+      static_cast<device::BluetoothRemoteGattCharacteristicMac*>(
+          characteristic);
+  CBCharacteristic* cb_characteristic =
+      mac_gatt_characteristic->GetCBCharacteristic();
+  return ObjCCast<MockCBCharacteristic>(cb_characteristic);
+}
+
 // Utility function for generating new (CBUUID, address) pairs where CBUUID
 // hashes to address. For use when adding a new device address to the testing
 // suite because CoreBluetooth peripherals have CBUUIDs in place of addresses,
 // and we construct fake addresses for them by hashing the CBUUID. By changing
 // |target| the user can generate sequentially numbered test addresses.
 //
 // std::string BluetoothTestMac::FindCBUUIDForHashTarget() {
 //   // The desired first 6 digits of the hash.  For example 0100000, 020000,
 //   // 030000, ...
 //   const std::string target = "010000";
@@ skipping 16 matching lines @@
 //     crypto::SHA256HashString(input_str, raw, sizeof(raw));
 //     if (base::HexEncode(raw, sizeof(raw)) == target) {
 //       return input_str;
 //     }
 //     ++input[0];
 //   }
 //   return "";
 // }
 
 }  // namespace device