You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
287 lines
9.9 KiB
287 lines
9.9 KiB
//
|
|
// Copyright 2015 Google, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at:
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#include <base/macros.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "service/adapter.h"
|
|
#include "service/hal/fake_bluetooth_gatt_interface.h"
|
|
#include "service/hal/fake_bluetooth_interface.h"
|
|
|
|
namespace bluetooth {
|
|
namespace {
|
|
|
|
class AdapterTest : public ::testing::Test {
|
|
public:
|
|
AdapterTest() = default;
|
|
~AdapterTest() override = default;
|
|
|
|
void SetUp() override {
|
|
fake_hal_manager_ = hal::FakeBluetoothInterface::GetManager();
|
|
fake_hal_iface_ = new hal::FakeBluetoothInterface();
|
|
hal::BluetoothInterface::InitializeForTesting(fake_hal_iface_);
|
|
|
|
// Initialize GATT interface with default handlers.
|
|
hal::BluetoothGattInterface::InitializeForTesting(
|
|
new hal::FakeBluetoothGattInterface(nullptr, nullptr, nullptr,
|
|
nullptr));
|
|
|
|
adapter_ = Adapter::Create();
|
|
}
|
|
|
|
void TearDown() override {
|
|
adapter_.reset();
|
|
hal::BluetoothGattInterface::CleanUp();
|
|
hal::BluetoothInterface::CleanUp();
|
|
}
|
|
|
|
protected:
|
|
hal::FakeBluetoothInterface* fake_hal_iface_;
|
|
hal::FakeBluetoothInterface::Manager* fake_hal_manager_;
|
|
std::unique_ptr<Adapter> adapter_;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(AdapterTest);
|
|
};
|
|
|
|
class TestObserver final : public bluetooth::Adapter::Observer {
|
|
public:
|
|
explicit TestObserver(bluetooth::Adapter* adapter)
|
|
: adapter_(adapter),
|
|
prev_state_(bluetooth::ADAPTER_STATE_INVALID),
|
|
cur_state_(bluetooth::ADAPTER_STATE_INVALID),
|
|
last_device_connected_state_(false) {
|
|
CHECK(adapter_);
|
|
adapter_->AddObserver(this);
|
|
}
|
|
|
|
~TestObserver() override { adapter_->RemoveObserver(this); }
|
|
|
|
bluetooth::AdapterState prev_state() const { return prev_state_; }
|
|
bluetooth::AdapterState cur_state() const { return cur_state_; }
|
|
|
|
std::string last_connection_state_address() const {
|
|
return last_connection_state_address_;
|
|
}
|
|
|
|
bool last_device_connected_state() const {
|
|
return last_device_connected_state_;
|
|
}
|
|
|
|
// bluetooth::Adapter::Observer override:
|
|
void OnAdapterStateChanged(bluetooth::Adapter* adapter,
|
|
bluetooth::AdapterState prev_state,
|
|
bluetooth::AdapterState new_state) override {
|
|
ASSERT_EQ(adapter_, adapter);
|
|
prev_state_ = prev_state;
|
|
cur_state_ = new_state;
|
|
}
|
|
|
|
void OnDeviceConnectionStateChanged(Adapter* adapter,
|
|
const std::string& device_address,
|
|
bool connected) override {
|
|
ASSERT_EQ(adapter_, adapter);
|
|
last_connection_state_address_ = device_address;
|
|
last_device_connected_state_ = connected;
|
|
}
|
|
|
|
private:
|
|
bluetooth::Adapter* adapter_;
|
|
bluetooth::AdapterState prev_state_, cur_state_;
|
|
std::string last_connection_state_address_;
|
|
bool last_device_connected_state_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(TestObserver);
|
|
};
|
|
|
|
TEST_F(AdapterTest, IsEnabled) {
|
|
EXPECT_FALSE(adapter_->IsEnabled());
|
|
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON);
|
|
EXPECT_TRUE(adapter_->IsEnabled());
|
|
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_OFF);
|
|
EXPECT_FALSE(adapter_->IsEnabled());
|
|
}
|
|
|
|
TEST_F(AdapterTest, Enable) {
|
|
TestObserver observer(adapter_.get());
|
|
|
|
EXPECT_FALSE(adapter_->IsEnabled());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState());
|
|
|
|
// Enable fails at HAL level
|
|
EXPECT_FALSE(adapter_->Enable());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState());
|
|
|
|
// Enable success
|
|
fake_hal_manager_->enable_succeed = true;
|
|
EXPECT_TRUE(adapter_->Enable());
|
|
|
|
// Should have received a state update.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, observer.cur_state());
|
|
|
|
// Enable fails because not disabled
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, adapter_->GetState());
|
|
EXPECT_FALSE(adapter_->Enable());
|
|
|
|
// Adapter state updates properly
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON);
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, adapter_->GetState());
|
|
|
|
// Should have received a state update.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_ON, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state());
|
|
|
|
// Enable fails because already enabled
|
|
EXPECT_FALSE(adapter_->Enable());
|
|
}
|
|
|
|
TEST_F(AdapterTest, Disable) {
|
|
TestObserver observer(adapter_.get());
|
|
|
|
fake_hal_manager_->disable_succeed = true;
|
|
EXPECT_FALSE(adapter_->IsEnabled());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState());
|
|
|
|
// Disable fails because already disabled
|
|
EXPECT_FALSE(adapter_->Disable());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, adapter_->GetState());
|
|
|
|
// Disable success
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON);
|
|
|
|
// Should have received a state update.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state());
|
|
|
|
EXPECT_TRUE(adapter_->Disable());
|
|
|
|
// Should have received a state update.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.cur_state());
|
|
|
|
// Disable fails because not enabled
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, adapter_->GetState());
|
|
EXPECT_FALSE(adapter_->Disable());
|
|
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_ON);
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, adapter_->GetState());
|
|
|
|
// Should have received a state update.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state());
|
|
|
|
// Disable fails at HAL level
|
|
fake_hal_manager_->disable_succeed = false;
|
|
EXPECT_FALSE(adapter_->Disable());
|
|
|
|
// Should have received a state update. In this case we will receive two
|
|
// updates: one going from OFF to TURNING_OFF, and one going from TURNING_OFF
|
|
// back to ON since we failed to initiate the disable operation.
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_TURNING_OFF, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.cur_state());
|
|
|
|
// Update state to OFF. Should receive a state update.
|
|
fake_hal_iface_->NotifyAdapterStateChanged(BT_STATE_OFF);
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_ON, observer.prev_state());
|
|
EXPECT_EQ(bluetooth::ADAPTER_STATE_OFF, observer.cur_state());
|
|
}
|
|
|
|
TEST_F(AdapterTest, GetName) {
|
|
EXPECT_EQ(bluetooth::Adapter::kDefaultName, adapter_->GetName());
|
|
|
|
const char kTestAdapterName[] = "Test Adapter Name";
|
|
|
|
fake_hal_iface_->NotifyAdapterNamePropertyChanged(kTestAdapterName);
|
|
EXPECT_EQ(kTestAdapterName, adapter_->GetName());
|
|
}
|
|
|
|
TEST_F(AdapterTest, SetName) {
|
|
bt_bdname_t hal_name;
|
|
|
|
// Name too large.
|
|
EXPECT_FALSE(adapter_->SetName(std::string(sizeof(hal_name.name), 'a')));
|
|
|
|
// Valid length.
|
|
EXPECT_FALSE(adapter_->SetName("Test Name"));
|
|
fake_hal_manager_->set_property_succeed = true;
|
|
EXPECT_TRUE(adapter_->SetName("Test Name"));
|
|
}
|
|
|
|
TEST_F(AdapterTest, GetAddress) {
|
|
EXPECT_EQ(bluetooth::Adapter::kDefaultAddress, adapter_->GetAddress());
|
|
|
|
const RawAddress kTestAdapterInput = {{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}};
|
|
const char kTestAdapterAddressOutput[] = "12:34:56:78:9A:BC";
|
|
|
|
fake_hal_iface_->NotifyAdapterAddressPropertyChanged(&kTestAdapterInput);
|
|
EXPECT_EQ(kTestAdapterAddressOutput, adapter_->GetAddress());
|
|
}
|
|
|
|
TEST_F(AdapterTest, IsMultiAdvertisementSupported) {
|
|
EXPECT_FALSE(adapter_->IsMultiAdvertisementSupported());
|
|
|
|
bt_local_le_features_t features;
|
|
memset(&features, 0, sizeof(features));
|
|
|
|
features.max_adv_instance = 10; // Some high number.
|
|
fake_hal_iface_->NotifyAdapterLocalLeFeaturesPropertyChanged(&features);
|
|
EXPECT_TRUE(adapter_->IsMultiAdvertisementSupported());
|
|
|
|
features.max_adv_instance = 0; // Low number.
|
|
fake_hal_iface_->NotifyAdapterLocalLeFeaturesPropertyChanged(&features);
|
|
EXPECT_FALSE(adapter_->IsMultiAdvertisementSupported());
|
|
}
|
|
|
|
TEST_F(AdapterTest, IsDeviceConnected) {
|
|
const char kDeviceAddr[] = "12:34:56:78:9A:BC";
|
|
TestObserver observer(adapter_.get());
|
|
|
|
EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr));
|
|
|
|
RawAddress hal_addr;
|
|
ASSERT_TRUE(RawAddress::FromString(kDeviceAddr, hal_addr));
|
|
|
|
// status != BT_STATUS_SUCCESS should be ignored
|
|
fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_FAIL, hal_addr,
|
|
BT_ACL_STATE_CONNECTED,
|
|
0xff); // HCI_ERR_UNDEFINED
|
|
EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr));
|
|
EXPECT_TRUE(observer.last_connection_state_address().empty());
|
|
EXPECT_FALSE(observer.last_device_connected_state());
|
|
|
|
// Connected
|
|
fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_SUCCESS, hal_addr,
|
|
BT_ACL_STATE_CONNECTED,
|
|
0x00); // HCI_SUCCESS
|
|
EXPECT_TRUE(adapter_->IsDeviceConnected(kDeviceAddr));
|
|
EXPECT_EQ(kDeviceAddr, observer.last_connection_state_address());
|
|
EXPECT_TRUE(observer.last_device_connected_state());
|
|
|
|
// Disconnected
|
|
fake_hal_iface_->NotifyAclStateChangedCallback(BT_STATUS_SUCCESS, hal_addr,
|
|
BT_ACL_STATE_DISCONNECTED,
|
|
0x16); // HCI_ERR_CONN_CAUSE_LOCAL_HOST
|
|
EXPECT_FALSE(adapter_->IsDeviceConnected(kDeviceAddr));
|
|
EXPECT_EQ(kDeviceAddr, observer.last_connection_state_address());
|
|
EXPECT_FALSE(observer.last_device_connected_state());
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace bluetooth
|