rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/packages/modules/Bluetooth/system/bta/groups/groups_test.cc

314 lines
12 KiB
C++
Raw Blame History

/*
* Copyright 2021 HIMSA II K/S - www.himsa.com.
* Represented by EHIMA - www.ehima.com
*
* 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/logging.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "bta_groups.h"
#include "types/bluetooth/uuid.h"
#include "types/raw_address.h"
std::map<std::string, int> mock_function_count_map;
namespace bluetooth {
namespace groups {
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::SetArgPointee;
using ::testing::Test;
using bluetooth::groups::DeviceGroups;
using bluetooth::groups::DeviceGroupsCallbacks;
DeviceGroupsCallbacks* dev_callbacks;
RawAddress GetTestAddress(int index) {
CHECK_LT(index, UINT8_MAX);
RawAddress result = {
{0xC0, 0xDE, 0xC0, 0xDE, 0x00, static_cast<uint8_t>(index)}};
return result;
}
class MockGroupsCallbacks : public DeviceGroupsCallbacks {
public:
MockGroupsCallbacks() = default;
MockGroupsCallbacks(const MockGroupsCallbacks&) = delete;
MockGroupsCallbacks& operator=(const MockGroupsCallbacks&) = delete;
~MockGroupsCallbacks() override = default;
MOCK_METHOD((void), OnGroupAdded,
(const RawAddress& address, const bluetooth::Uuid& uuid,
int group_id),
(override));
MOCK_METHOD((void), OnGroupMemberAdded,
(const RawAddress& address, int group_id), (override));
MOCK_METHOD((void), OnGroupRemoved,
(const bluetooth::Uuid& uuid, int group_id), (override));
MOCK_METHOD((void), OnGroupMemberRemoved,
(const RawAddress& address, int group_id), (override));
MOCK_METHOD((void), OnGroupAddFromStorage,
(const RawAddress& address, const bluetooth::Uuid& uuid,
int group_id),
(override));
};
class GroupsTest : public ::testing::Test {
protected:
void SetUp() override {
mock_function_count_map.clear();
callbacks.reset(new MockGroupsCallbacks());
}
void TearDown() override { DeviceGroups::CleanUp(callbacks.get()); }
std::unique_ptr<MockGroupsCallbacks> callbacks;
};
TEST_F(GroupsTest, test_initialize) {
DeviceGroups::Initialize(callbacks.get());
ASSERT_TRUE(DeviceGroups::Get());
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_initialize_twice) {
DeviceGroups::Initialize(callbacks.get());
DeviceGroups* dev_groups_p = DeviceGroups::Get();
DeviceGroups::Initialize(callbacks.get());
ASSERT_EQ(dev_groups_p, DeviceGroups::Get());
DeviceGroups::CleanUp(callbacks.get());
dev_groups_p->CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_cleanup_initialized) {
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::CleanUp(callbacks.get());
ASSERT_FALSE(DeviceGroups::Get());
}
TEST_F(GroupsTest, test_cleanup_uninitialized) {
DeviceGroups::CleanUp(callbacks.get());
ASSERT_FALSE(DeviceGroups::Get());
}
TEST_F(GroupsTest, test_groups_add_single_device) {
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(1), Uuid::kEmpty, 7));
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 7);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_groups_add_two_devices) {
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(1), _, 7));
EXPECT_CALL(*callbacks, OnGroupMemberAdded(GetTestAddress(2), 7));
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 7);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_groups_remove_device) {
EXPECT_CALL(*callbacks, OnGroupMemberRemoved(GetTestAddress(2), 7));
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 7);
DeviceGroups::Get()->RemoveDevice(GetTestAddress(2));
ASSERT_EQ(kGroupUnknown,
DeviceGroups::Get()->GetGroupId(GetTestAddress(2), Uuid::kEmpty));
ASSERT_EQ(kGroupUnknown,
DeviceGroups::Get()->GetGroupId(GetTestAddress(3), Uuid::kEmpty));
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_add_multiple_devices) {
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(2), Uuid::kEmpty, 7));
EXPECT_CALL(*callbacks, OnGroupMemberAdded(_, 7)).Times(2);
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(3), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(4), Uuid::kEmpty, 7);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_remove_multiple_devices) {
EXPECT_CALL(*callbacks, OnGroupMemberRemoved(_, _)).Times(3);
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(3), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(4), Uuid::kEmpty, 7);
DeviceGroups::Get()->RemoveDevice(GetTestAddress(2));
DeviceGroups::Get()->RemoveDevice(GetTestAddress(3));
DeviceGroups::Get()->RemoveDevice(GetTestAddress(4));
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_add_multiple_groups) {
EXPECT_CALL(*callbacks, OnGroupAdded(_, _, _)).Times(2);
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 8);
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 9);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_remove_multiple_groups) {
Uuid uuid1 = Uuid::GetRandom();
Uuid uuid2 = Uuid::GetRandom();
ASSERT_NE(uuid1, uuid2);
EXPECT_CALL(*callbacks, OnGroupAdded(_, _, _)).Times(2);
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(1), uuid1, 8);
DeviceGroups::Get()->AddDevice(GetTestAddress(1), uuid2, 9);
DeviceGroups::Get()->AddDevice(GetTestAddress(2), uuid2, 9);
EXPECT_CALL(*callbacks, OnGroupMemberRemoved(GetTestAddress(1), 8));
EXPECT_CALL(*callbacks, OnGroupMemberRemoved(GetTestAddress(1), 9));
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid1, 8));
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid2, 9)).Times(0);
DeviceGroups::Get()->RemoveDevice(GetTestAddress(1));
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_remove_device_fo_devices) {
Uuid uuid1 = Uuid::GetRandom();
Uuid uuid2 = Uuid::GetRandom();
EXPECT_CALL(*callbacks, OnGroupAdded(_, _, _)).Times(2);
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(1), uuid1, 8);
DeviceGroups::Get()->AddDevice(GetTestAddress(1), uuid2, 9);
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid1, 8));
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid2, 9)).Times(0);
DeviceGroups::Get()->RemoveDevice(GetTestAddress(1), 8);
Mock::VerifyAndClearExpectations(&callbacks);
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid1, 8)).Times(0);
EXPECT_CALL(*callbacks, OnGroupRemoved(uuid2, 9));
DeviceGroups::Get()->RemoveDevice(GetTestAddress(1), 9);
}
TEST_F(GroupsTest, test_add_devices_different_group_id) {
DeviceGroups::Initialize(callbacks.get());
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 10);
DeviceGroups::Get()->AddDevice(GetTestAddress(3), Uuid::kEmpty, 11);
auto group_id_1 =
DeviceGroups::Get()->GetGroupId(GetTestAddress(2), Uuid::kEmpty);
auto group_id_2 =
DeviceGroups::Get()->GetGroupId(GetTestAddress(3), Uuid::kEmpty);
ASSERT_TRUE(group_id_1 != group_id_2);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_group_id_assign) {
int captured_gid1 = kGroupUnknown;
int captured_gid2 = kGroupUnknown;
DeviceGroups::Initialize(callbacks.get());
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(1), _, _))
.WillOnce(SaveArg<2>(&captured_gid1));
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(2), _, _))
.WillOnce(SaveArg<2>(&captured_gid2));
int gid1 = DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty,
bluetooth::groups::kGroupUnknown);
int gid2 = DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty);
int gid3 = DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty);
ASSERT_NE(bluetooth::groups::kGroupUnknown, gid1);
ASSERT_NE(bluetooth::groups::kGroupUnknown, gid2);
ASSERT_EQ(gid2, gid3);
ASSERT_EQ(gid1, captured_gid1);
ASSERT_EQ(gid2, captured_gid2);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_storage_calls) {
ASSERT_EQ(0, mock_function_count_map["btif_storage_load_bonded_groups"]);
DeviceGroups::Initialize(callbacks.get());
ASSERT_EQ(1, mock_function_count_map["btif_storage_load_bonded_groups"]);
ASSERT_EQ(0, mock_function_count_map["btif_storage_add_groups"]);
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(1), Uuid::kEmpty, 8);
ASSERT_EQ(2, mock_function_count_map["btif_storage_add_groups"]);
DeviceGroups::Get()->AddDevice(GetTestAddress(2), Uuid::kEmpty, 7);
DeviceGroups::Get()->AddDevice(GetTestAddress(3), Uuid::kEmpty, 7);
ASSERT_EQ(4, mock_function_count_map["btif_storage_add_groups"]);
ASSERT_EQ(0, mock_function_count_map["btif_storage_remove_groups"]);
DeviceGroups::Get()->RemoveDevice(GetTestAddress(1));
DeviceGroups::Get()->RemoveDevice(GetTestAddress(2));
DeviceGroups::Get()->RemoveDevice(GetTestAddress(3));
ASSERT_EQ(3, mock_function_count_map["btif_storage_remove_groups"]);
DeviceGroups::CleanUp(callbacks.get());
}
TEST_F(GroupsTest, test_storage_content) {
int gid1 = bluetooth::groups::kGroupUnknown;
int gid2 = bluetooth::groups::kGroupUnknown;
Uuid uuid1 = Uuid::GetRandom();
Uuid uuid2 = Uuid::GetRandom();
ASSERT_NE(uuid1, uuid2);
DeviceGroups::Initialize(callbacks.get());
gid1 = DeviceGroups::Get()->AddDevice(GetTestAddress(1), uuid1, gid1);
DeviceGroups::Get()->AddDevice(GetTestAddress(2), uuid1, gid1);
gid2 = DeviceGroups::Get()->AddDevice(GetTestAddress(2), uuid2, gid2);
ASSERT_NE(bluetooth::groups::kGroupUnknown, gid1);
ASSERT_NE(gid1, gid2);
std::vector<uint8_t> dev1_storage;
std::vector<uint8_t> dev2_storage;
// Store to byte buffer
DeviceGroups::GetForStorage(GetTestAddress(1), dev1_storage);
DeviceGroups::GetForStorage(GetTestAddress(2), dev2_storage);
ASSERT_NE(0u, dev1_storage.size());
ASSERT_TRUE(dev2_storage.size() > dev1_storage.size());
// Clean it up
DeviceGroups::CleanUp(callbacks.get());
ASSERT_EQ(nullptr, DeviceGroups::Get());
// Restore dev1 from the byte buffer
DeviceGroups::Initialize(callbacks.get());
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(1), uuid1, gid1));
DeviceGroups::AddFromStorage(GetTestAddress(1), dev1_storage);
// Restore dev2 from the byte buffer
EXPECT_CALL(*callbacks, OnGroupAdded(GetTestAddress(2), uuid2, gid2));
EXPECT_CALL(*callbacks, OnGroupMemberAdded(GetTestAddress(2), gid1)).Times(1);
DeviceGroups::AddFromStorage(GetTestAddress(2), dev2_storage);
DeviceGroups::CleanUp(callbacks.get());
}
} // namespace groups
} // namespace bluetooth
Reference in New Issue View Git Blame Copy Permalink