Index: device/bluetooth/test/bluetooth_gatt_server_test.cc |
diff --git a/device/bluetooth/test/bluetooth_gatt_server_test.cc b/device/bluetooth/test/bluetooth_gatt_server_test.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..66c7b41dbfd205bf5992ca14673dd24ef3d0cae1 |
--- /dev/null |
+++ b/device/bluetooth/test/bluetooth_gatt_server_test.cc |
@@ -0,0 +1,162 @@ |
+// Copyright 2016 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_gatt_server_test.h" |
+ |
+#include "base/callback.h" |
+#include "base/logging.h" |
+#include "base/memory/ptr_util.h" |
+#include "base/memory/ref_counted.h" |
+#include "device/bluetooth/bluetooth_gatt_characteristic.h" |
+#include "device/bluetooth/bluetooth_uuid.h" |
+#include "device/bluetooth/test/bluetooth_test.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace device { |
+ |
+// TestLocalGattServiceDelegate: |
+ |
+bool TestLocalGattServiceDelegate::should_fail_ = false; |
+uint64_t TestLocalGattServiceDelegate::last_written_value_ = 0; |
+uint64_t TestLocalGattServiceDelegate::value_to_write_ = 0; |
+ |
+TestLocalGattServiceDelegate::TestLocalGattServiceDelegate() |
+ : expected_service_(nullptr), |
+ expected_characteristic_(nullptr), |
+ expected_descriptor_(nullptr) {} |
+ |
+void TestLocalGattServiceDelegate::OnCharacteristicReadRequest( |
+ const BluetoothLocalGattService* service, |
+ const BluetoothLocalGattCharacteristic* characteristic, |
+ int offset, |
+ const ValueCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ EXPECT_EQ(expected_service_, service); |
+ EXPECT_EQ(expected_characteristic_, characteristic); |
+ if (should_fail_) { |
+ error_callback.Run(); |
+ return; |
+ } |
+ callback.Run(BluetoothGattServerTest::GetValue(value_to_write_)); |
+} |
+ |
+void TestLocalGattServiceDelegate::OnCharacteristicWriteRequest( |
+ const BluetoothLocalGattService* service, |
+ const BluetoothLocalGattCharacteristic* characteristic, |
+ const std::vector<uint8_t>& value, |
+ int offset, |
+ const base::Closure& callback, |
+ const ErrorCallback& error_callback) { |
+ EXPECT_EQ(expected_service_, service); |
+ EXPECT_EQ(expected_characteristic_, characteristic); |
+ if (should_fail_) { |
+ error_callback.Run(); |
+ return; |
+ } |
+ last_written_value_ = BluetoothGattServerTest::GetInteger(value); |
+ callback.Run(); |
+} |
+ |
+void TestLocalGattServiceDelegate::OnDescriptorReadRequest( |
+ const BluetoothLocalGattService* service, |
+ const BluetoothLocalGattDescriptor* descriptor, |
+ int offset, |
+ const ValueCallback& callback, |
+ const ErrorCallback& error_callback) { |
+ EXPECT_EQ(expected_service_, service); |
+ EXPECT_EQ(expected_descriptor_, descriptor); |
+ if (should_fail_) { |
+ error_callback.Run(); |
+ return; |
+ } |
+ callback.Run(BluetoothGattServerTest::GetValue(value_to_write_)); |
+} |
+ |
+void TestLocalGattServiceDelegate::OnDescriptorWriteRequest( |
+ const BluetoothLocalGattService* service, |
+ const BluetoothLocalGattDescriptor* descriptor, |
+ const std::vector<uint8_t>& value, |
+ int offset, |
+ const base::Closure& callback, |
+ const ErrorCallback& error_callback) { |
+ EXPECT_EQ(expected_service_, service); |
+ EXPECT_EQ(expected_descriptor_, descriptor); |
+ if (should_fail_) { |
+ error_callback.Run(); |
+ return; |
+ } |
+ last_written_value_ = BluetoothGattServerTest::GetInteger(value); |
+ callback.Run(); |
+} |
+ |
+// BluetoothGattServerTest: |
+ |
+BluetoothGattServerTest::BluetoothGattServerTest() {} |
+ |
+BluetoothGattServerTest::~BluetoothGattServerTest() {} |
+ |
+void BluetoothGattServerTest::StartGattSetup() { |
+ InitWithFakeAdapter(); |
+ delegate_ = base::WrapUnique(new TestLocalGattServiceDelegate()); |
+ service_ = BluetoothLocalGattService::Create( |
+ adapter_.get(), BluetoothUUID(kTestUUIDGenericAttribute), true, nullptr, |
+ delegate_.get()); |
+ delegate_->set_expected_service(service_.get()); |
+} |
+ |
+void BluetoothGattServerTest::CompleteGattSetup() { |
+ service_->Register(GetCallback(Call::EXPECTED), |
+ GetGattErrorCallback(Call::NOT_EXPECTED)); |
+ EXPECT_EQ(1, callback_count_); |
+ EXPECT_EQ(0, error_callback_count_); |
+} |
+ |
+void BluetoothGattServerTest::SetUp() { |
+ BluetoothTest::SetUp(); |
+ |
+ last_read_value_ = std::vector<uint8_t>(); |
+ TestLocalGattServiceDelegate::value_to_write_ = 0; |
+ TestLocalGattServiceDelegate::last_written_value_ = 0; |
+ TestLocalGattServiceDelegate::should_fail_ = false; |
+} |
+ |
+void BluetoothGattServerTest::TearDown() { |
+ int callback_count = callback_count_; |
+ int error_callback_count = error_callback_count_; |
+ service_->Unregister(GetCallback(Call::EXPECTED), |
+ GetGattErrorCallback(Call::NOT_EXPECTED)); |
+ EXPECT_EQ(callback_count + 1, callback_count_); |
+ EXPECT_EQ(error_callback_count, error_callback_count_); |
+ |
+ delegate_ = nullptr; |
+ |
+ BluetoothTest::TearDown(); |
+} |
+ |
+// static |
+uint64_t BluetoothGattServerTest::GetInteger( |
+ const std::vector<uint8_t>& value) { |
+ // Handling only up to 4 bytes value for tests. |
+ CHECK_LE(value.size(), 4u); |
+ uint64_t int_value = 0; |
+ uint64_t powers_of_256 = 1; |
+ for (uint8_t v : value) { |
+ int_value += v * powers_of_256; |
+ powers_of_256 *= 256; |
+ } |
+ return int_value; |
+} |
+ |
+// static |
+std::vector<uint8_t> BluetoothGattServerTest::GetValue(uint64_t int_value) { |
+ CHECK_LE(int_value, 0xFFFFFFFFul); |
+ std::vector<uint8_t> value; |
+ while (int_value) { |
+ value.push_back(int_value & 0xff); |
+ int_value >>= 8; |
+ } |
+ return value; |
+} |
+ |
+} // namespace device |