1 /*
2 * Copyright 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <stdlib.h>
19
20 #include <cstddef>
21
22 #include "btif/include/btif_storage.h"
23 #include "btif/include/stack_manager_t.h"
24 #include "device/include/interop.h"
25 #include "mock_btif_config.h"
26 #include "osi/include/allocator.h"
27 #include "profile/avrcp/avrcp_config.h"
28 #include "stack/include/avrc_api.h"
29 #include "stack/include/avrc_defs.h"
30 #include "stack/include/bt_types.h"
31 #include "stack/include/bt_uuid16.h"
32 #include "stack/sdp/sdpint.h"
33 #include "test/fake/fake_osi.h"
34 #include "test/mock/mock_btif_config.h"
35 #include "test/mock/mock_osi_allocator.h"
36 #include "test/mock/mock_osi_properties.h"
37 #include "test/mock/mock_stack_l2cap_interface.h"
38
39 #ifndef BT_DEFAULT_BUFFER_SIZE
40 #define BT_DEFAULT_BUFFER_SIZE (4096 + 16)
41 #endif
42
43 #define INVALID_LENGTH 5
44 #define INVALID_UUID 0X1F
45 #define UUID_HF_LSB 0X1E
46
47 #define PROFILE_VERSION_POSITION 7
48 #define SDP_PROFILE_DESC_LENGTH 8
49 #define HFP_PROFILE_MINOR_VERSION_6 0x06
50 #define HFP_PROFILE_MINOR_VERSION_7 0x07
51
52 // TODO(b/369381361) Enfore -Wmissing-prototypes
53 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
54
55 static int L2CA_ConnectReqWithSecurity_cid = 0x42;
56 static RawAddress addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
57 static tSDP_DISCOVERY_DB* sdp_db = nullptr;
58
59 using ::testing::_;
60 using ::testing::DoAll;
61 using ::testing::Invoke;
62 using ::testing::Return;
63 using ::testing::ReturnArg;
64 using ::testing::SaveArg;
65 using ::testing::SetArrayArgument;
66
67 void sdp_callback(const RawAddress& bd_addr, tSDP_RESULT result);
68 tCONN_CB* find_ccb(uint16_t cid, uint8_t state);
69
70 namespace {
71 // convenience mock
72 class IopMock {
73 public:
74 MOCK_METHOD(bool, InteropMatchAddr, (const interop_feature_t, const RawAddress*));
75 MOCK_METHOD(bool, InteropMatchName, (const interop_feature_t, const char*));
76 MOCK_METHOD(void, InteropDatabaseAdd, (uint16_t, const RawAddress*, size_t));
77 MOCK_METHOD(void, InteropDatabaseClear, ());
78 MOCK_METHOD(bool, InteropMatchAddrOrName,
79 (const interop_feature_t, const RawAddress*,
80 bt_status_t (*)(const RawAddress*, bt_property_t*)));
81 MOCK_METHOD(bool, InteropMatchManufacturer, (const interop_feature_t, uint16_t));
82 MOCK_METHOD(bool, InteropMatchVendorProductIds, (const interop_feature_t, uint16_t, uint16_t));
83 MOCK_METHOD(bool, InteropDatabaseMatchVersion, (const interop_feature_t, uint16_t));
84 MOCK_METHOD(bool, InteropMatchAddrGetMaxLat,
85 (const interop_feature_t, const RawAddress*, uint16_t*));
86 MOCK_METHOD(bool, InteropGetAllowlistedMediaPlayersList, (list_t*));
87 MOCK_METHOD(int, InteropFeatureNameToFeatureId, (const char*));
88 MOCK_METHOD(void, InteropDatabaseAddAddr, (uint16_t, const RawAddress*, size_t));
89 };
90
91 class AvrcpVersionMock {
92 public:
93 MOCK_METHOD0(AvrcpProfileVersionMock, uint16_t(void));
94 };
95
96 std::unique_ptr<IopMock> localIopMock;
97 std::unique_ptr<AvrcpVersionMock> localAvrcpVersionMock;
98 } // namespace
99
interop_match_addr(const interop_feature_t feature,const RawAddress * addr)100 bool interop_match_addr(const interop_feature_t feature, const RawAddress* addr) {
101 return localIopMock->InteropMatchAddr(feature, addr);
102 }
interop_match_name(const interop_feature_t feature,const char * name)103 bool interop_match_name(const interop_feature_t feature, const char* name) {
104 return localIopMock->InteropMatchName(feature, name);
105 }
interop_database_add(uint16_t feature,const RawAddress * addr,size_t length)106 void interop_database_add(uint16_t feature, const RawAddress* addr, size_t length) {
107 return localIopMock->InteropDatabaseAdd(feature, addr, length);
108 }
interop_database_clear()109 void interop_database_clear() { localIopMock->InteropDatabaseClear(); }
110
interop_match_addr_or_name(const interop_feature_t feature,const RawAddress * addr,bt_status_t (* get_remote_device_property)(const RawAddress *,bt_property_t *))111 bool interop_match_addr_or_name(const interop_feature_t feature, const RawAddress* addr,
112 bt_status_t (*get_remote_device_property)(const RawAddress*,
113 bt_property_t*)) {
114 return localIopMock->InteropMatchAddrOrName(feature, addr, get_remote_device_property);
115 }
116
interop_match_manufacturer(const interop_feature_t feature,uint16_t manufacturer)117 bool interop_match_manufacturer(const interop_feature_t feature, uint16_t manufacturer) {
118 return localIopMock->InteropMatchManufacturer(feature, manufacturer);
119 }
120
interop_match_vendor_product_ids(const interop_feature_t feature,uint16_t vendor_id,uint16_t product_id)121 bool interop_match_vendor_product_ids(const interop_feature_t feature, uint16_t vendor_id,
122 uint16_t product_id) {
123 return localIopMock->InteropMatchVendorProductIds(feature, vendor_id, product_id);
124 }
125
interop_database_match_version(const interop_feature_t feature,uint16_t version)126 bool interop_database_match_version(const interop_feature_t feature, uint16_t version) {
127 return localIopMock->InteropDatabaseMatchVersion(feature, version);
128 }
interop_match_addr_get_max_lat(const interop_feature_t feature,const RawAddress * addr,uint16_t * max_lat)129 bool interop_match_addr_get_max_lat(const interop_feature_t feature, const RawAddress* addr,
130 uint16_t* max_lat) {
131 return localIopMock->InteropMatchAddrGetMaxLat(feature, addr, max_lat);
132 }
133
interop_feature_name_to_feature_id(const char * feature_name)134 int interop_feature_name_to_feature_id(const char* feature_name) {
135 return localIopMock->InteropFeatureNameToFeatureId(feature_name);
136 }
137
interop_database_add_addr(uint16_t feature,const RawAddress * addr,size_t length)138 void interop_database_add_addr(uint16_t feature, const RawAddress* addr, size_t length) {
139 return localIopMock->InteropDatabaseAddAddr(feature, addr, length);
140 }
141
AVRC_GetProfileVersion()142 uint16_t AVRC_GetProfileVersion() { return localAvrcpVersionMock->AvrcpProfileVersionMock(); }
143
144 uint8_t avrc_value[8] = {
145 ((DATA_ELE_SEQ_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE), // data_element
146 6, // data_len
147 ((UUID_DESC_TYPE << 3) | SIZE_TWO_BYTES), // uuid_element
148 0, // uuid
149 0, // uuid
150 ((UINT_DESC_TYPE << 3) | SIZE_TWO_BYTES), // version_element
151 0, // version
152 0 // version
153 };
154 tSDP_ATTRIBUTE avrcp_attr = {
155 .len = 0,
156 .value_ptr = (uint8_t*)(&avrc_value),
157 .id = 0,
158 .type = 0,
159 };
160
161 uint8_t avrc_feat_value[2] = {
162 0, // feature
163 0 // feature
164 };
165 tSDP_ATTRIBUTE avrcp_feat_attr = {
166 .len = 0,
167 .value_ptr = (uint8_t*)(&avrc_feat_value),
168 .id = 0,
169 .type = 0,
170 };
171
172 uint8_t hfp_value[8] = {0, 0, 0, 0x11, 0x1E, 0, 0, 0};
173
174 tSDP_ATTRIBUTE hfp_attr = {
175 .len = 0,
176 .value_ptr = (uint8_t*)(hfp_value),
177 .id = 0,
178 .type = 0,
179 };
180
set_hfp_attr(uint32_t len,uint16_t id,uint16_t uuid)181 void set_hfp_attr(uint32_t len, uint16_t id, uint16_t uuid) {
182 hfp_attr.value_ptr[4] = uuid;
183 hfp_attr.len = len;
184 hfp_attr.id = id;
185 }
186
set_avrcp_feat_attr(uint32_t len,uint16_t id,uint16_t feature)187 void set_avrcp_feat_attr(uint32_t len, uint16_t id, uint16_t feature) {
188 UINT16_TO_BE_FIELD(avrc_feat_value, feature);
189 avrcp_feat_attr.len = len;
190 avrcp_feat_attr.id = id;
191 }
192
set_avrcp_attr(uint32_t len,uint16_t id,uint16_t uuid,uint16_t version)193 void set_avrcp_attr(uint32_t len, uint16_t id, uint16_t uuid, uint16_t version) {
194 UINT16_TO_BE_FIELD(avrc_value + 3, uuid);
195 UINT16_TO_BE_FIELD(avrc_value + 6, version);
196 avrcp_attr.len = len;
197 avrcp_attr.id = id;
198 }
199
get_avrc_target_version(tSDP_ATTRIBUTE * p_attr)200 uint16_t get_avrc_target_version(tSDP_ATTRIBUTE* p_attr) {
201 uint8_t* p_version = p_attr->value_ptr + 6;
202 uint16_t version = (((uint16_t)(*(p_version))) << 8) + ((uint16_t)(*((p_version) + 1)));
203 return version;
204 }
205
get_avrc_target_feature(tSDP_ATTRIBUTE * p_attr)206 uint16_t get_avrc_target_feature(tSDP_ATTRIBUTE* p_attr) {
207 uint8_t* p_feature = p_attr->value_ptr;
208 uint16_t feature = (((uint16_t)(*(p_feature))) << 8) + ((uint16_t)(*((p_feature) + 1)));
209 return feature;
210 }
211
212 class StackSdpMockAndFakeTest : public ::testing::Test {
213 protected:
SetUp()214 void SetUp() override {
215 fake_osi_ = std::make_unique<test::fake::FakeOsi>();
216 bluetooth::testing::stack::l2cap::set_interface(&mock_stack_l2cap_interface_);
217 EXPECT_CALL(mock_stack_l2cap_interface_, L2CA_RegisterWithSecurity(_, _, _, _, _, _, _))
218 .WillOnce(DoAll(SaveArg<1>(&l2cap_callbacks_), ::testing::ReturnArg<0>()));
219 EXPECT_CALL(mock_stack_l2cap_interface_, L2CA_Deregister(_));
220 }
221
TearDown()222 void TearDown() override {
223 bluetooth::testing::stack::l2cap::reset_interface();
224 fake_osi_.reset();
225 }
226
227 tL2CAP_APPL_INFO l2cap_callbacks_{};
228 bluetooth::testing::stack::l2cap::Mock mock_stack_l2cap_interface_;
229 std::unique_ptr<test::fake::FakeOsi> fake_osi_;
230 };
231
232 class StackSdpInitTest : public StackSdpMockAndFakeTest {
233 protected:
SetUp()234 void SetUp() override {
235 StackSdpMockAndFakeTest::SetUp();
236 sdp_init();
237 sdp_db = (tSDP_DISCOVERY_DB*)osi_malloc(BT_DEFAULT_BUFFER_SIZE);
238 }
239
TearDown()240 void TearDown() override {
241 osi_free(sdp_db);
242 sdp_free();
243 StackSdpMockAndFakeTest::TearDown();
244 }
245 };
246
247 class StackSdpUtilsTest : public StackSdpInitTest {
248 protected:
SetUp()249 void SetUp() override {
250 StackSdpInitTest::SetUp();
251 GetInterfaceToProfiles()->profileSpecific_HACK->AVRC_GetProfileVersion = AVRC_GetProfileVersion;
252 test::mock::btif_config::btif_config_get_bin.body = [this](const std::string& section,
253 const std::string& key,
254 uint8_t* value, size_t* length) {
255 return btif_config_interface_.GetBin(section, key, value, length);
256 };
257 test::mock::btif_config::btif_config_get_bin_length.body = [this](const std::string& section,
258 const std::string& key) {
259 return btif_config_interface_.GetBinLength(section, key);
260 };
261 test::mock::osi_properties::osi_property_get_bool.body =
262 [](const char* /* key */, bool /* default_value */) { return true; };
263
264 localIopMock = std::make_unique<IopMock>();
265 localAvrcpVersionMock = std::make_unique<AvrcpVersionMock>();
266 set_avrcp_attr(8, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_SERVCLASS_AV_REMOTE_CONTROL, AVRC_REV_1_5);
267 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
268 set_hfp_attr(SDP_PROFILE_DESC_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_HF_LSB);
269 }
270
TearDown()271 void TearDown() override {
272 GetInterfaceToProfiles()->profileSpecific_HACK->AVRC_GetProfileVersion = nullptr;
273 test::mock::btif_config::btif_config_get_bin_length = {};
274 test::mock::btif_config::btif_config_get_bin = {};
275 test::mock::osi_properties::osi_property_get_bool = {};
276
277 localIopMock.reset();
278 localAvrcpVersionMock.reset();
279 StackSdpInitTest::TearDown();
280 }
281 bluetooth::manager::MockBtifConfigInterface btif_config_interface_;
282 };
283
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_device_in_iop_table_version_1_4)284 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_device_in_iop_table_version_1_4) {
285 RawAddress bdaddr;
286 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
287 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
288 .WillOnce(Return(true));
289 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
290 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_4);
291 }
292
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_device_in_iop_table_version_1_3)293 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_device_in_iop_table_version_1_3) {
294 RawAddress bdaddr;
295 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
296 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
297 .WillOnce(Return(false));
298 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
299 .WillOnce(Return(true));
300 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
301 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_3);
302 }
303
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_wrong_len)304 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_wrong_len) {
305 RawAddress bdaddr;
306 set_avrcp_attr(5, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_SERVCLASS_AV_REMOTE_CONTROL, AVRC_REV_1_5);
307 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
308 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
309 }
310
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_wrong_attribute_id)311 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_wrong_attribute_id) {
312 RawAddress bdaddr;
313 set_avrcp_attr(8, ATTR_ID_SERVICE_CLASS_ID_LIST, UUID_SERVCLASS_AV_REMOTE_CONTROL, AVRC_REV_1_5);
314 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
315 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
316 }
317
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_wrong_uuid)318 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_wrong_uuid) {
319 RawAddress bdaddr;
320 set_avrcp_attr(8, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_SERVCLASS_AUDIO_SOURCE, AVRC_REV_1_5);
321 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
322 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
323 }
324
325 // device's controller version older than our target version
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_device_older_version)326 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_device_older_version) {
327 RawAddress bdaddr;
328 uint8_t config_0104[2] = {0x04, 0x01};
329 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
330 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
331 .WillOnce(Return(false));
332 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
333 .WillOnce(Return(false));
334 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
335 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
336 .WillOnce(DoAll(SetArrayArgument<2>(config_0104, config_0104 + 2), Return(true)));
337 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
338 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_4);
339 }
340
341 // device's controller version same as our target version
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_device_same_version)342 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_device_same_version) {
343 RawAddress bdaddr;
344 uint8_t config_0105[2] = {0x05, 0x01};
345 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
346 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
347 .WillOnce(Return(false));
348 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
349 .WillOnce(Return(false));
350 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
351 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
352 .WillOnce(DoAll(SetArrayArgument<2>(config_0105, config_0105 + 2), Return(true)));
353 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
354 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
355 }
356
357 // device's controller version higher than our target version
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_device_newer_version)358 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_device_newer_version) {
359 RawAddress bdaddr;
360 uint8_t config_0106[2] = {0x06, 0x01};
361 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
362 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
363 .WillOnce(Return(false));
364 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
365 .WillOnce(Return(false));
366 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
367 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
368 .WillOnce(DoAll(SetArrayArgument<2>(config_0106, config_0106 + 2), Return(true)));
369 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
370 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
371 }
372
373 // cannot read device's controller version from bt_config
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_no_config_value)374 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_no_config_value) {
375 RawAddress bdaddr;
376 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
377 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
378 .WillOnce(Return(false));
379 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
380 .WillOnce(Return(false));
381 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(0));
382 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
383 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
384 }
385
386 // read device's controller version from bt_config return only 1 byte
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_config_value_1_byte)387 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_config_value_1_byte) {
388 RawAddress bdaddr;
389 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
390 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
391 .WillOnce(Return(false));
392 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
393 .WillOnce(Return(false));
394 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(1));
395 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
396 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
397 }
398
399 // read device's controller version from bt_config return 3 bytes
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_config_value_3_bytes)400 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_config_value_3_bytes) {
401 RawAddress bdaddr;
402 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
403 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
404 .WillOnce(Return(false));
405 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
406 .WillOnce(Return(false));
407 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(3));
408 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
409 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
410 }
411
412 // cached controller version is not valid
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_version_config_value_not_valid)413 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_version_config_value_not_valid) {
414 RawAddress bdaddr;
415 uint8_t config_not_valid[2] = {0x12, 0x34};
416 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
417 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
418 .WillOnce(Return(false));
419 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
420 .WillOnce(Return(false));
421 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
422 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
423 .WillOnce(
424 DoAll(SetArrayArgument<2>(config_not_valid, config_not_valid + 2), Return(true)));
425 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
426 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
427 }
428
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_wrong_len)429 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_wrong_len) {
430 RawAddress bdaddr;
431 set_avrcp_attr(8, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_SERVCLASS_AV_REMOTE_CONTROL, AVRC_REV_1_5);
432 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
433 set_avrcp_feat_attr(6, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
434 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
435 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
436 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_5);
437 }
438
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_wrong_attribute_id)439 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_wrong_attribute_id) {
440 RawAddress bdaddr;
441 set_avrcp_attr(8, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_SERVCLASS_AV_REMOTE_CONTROL, AVRC_REV_1_5);
442 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
443 set_avrcp_feat_attr(2, ATTR_ID_BT_PROFILE_DESC_LIST, AVRCP_SUPF_TG_1_5);
444 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
445 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
446 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_5);
447 }
448
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_device_in_iop_table_version_1_4)449 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_device_in_iop_table_version_1_4) {
450 RawAddress bdaddr;
451 uint8_t feature_0105[2] = {0xC1, 0x00};
452 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
453 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
454 .WillOnce(Return(true));
455 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
456 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_4);
457 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
458 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
459 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
460 .WillOnce(DoAll(SetArrayArgument<2>(feature_0105, feature_0105 + 2), Return(true)));
461 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
462 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_4);
463 }
464
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_device_in_iop_table_version_1_3)465 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_device_in_iop_table_version_1_3) {
466 RawAddress bdaddr;
467 uint8_t feature_0105[2] = {0xC1, 0x00};
468 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
469 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
470 .WillOnce(Return(false));
471 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
472 .WillOnce(Return(true));
473 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
474 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_3);
475 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
476 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
477 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
478 .WillOnce(DoAll(SetArrayArgument<2>(feature_0105, feature_0105 + 2), Return(true)));
479 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
480 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_3);
481 }
482
483 // cannot read device's controller feature from bt_config
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_no_config_value)484 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_no_config_value) {
485 RawAddress bdaddr;
486 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
487 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
488 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
489 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(0));
490 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
491 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
492 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_5);
493 }
494
495 // read device's controller feature from bt_config return only 1 byte
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_config_value_1_byte)496 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_config_value_1_byte) {
497 RawAddress bdaddr;
498 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_5));
499 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
500 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_5);
501 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(1));
502 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
503 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
504 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr), AVRCP_SUPF_TG_1_5);
505 }
506
TEST_F(StackSdpUtilsTest,sdpu_set_avrc_target_feature_device_version_1_6)507 TEST_F(StackSdpUtilsTest, sdpu_set_avrc_target_feature_device_version_1_6) {
508 RawAddress bdaddr;
509 uint8_t config_0106[2] = {0x06, 0x01};
510 uint8_t feature_0106[2] = {0xC1, 0x01};
511 EXPECT_CALL(*localAvrcpVersionMock, AvrcpProfileVersionMock()).WillOnce(Return(AVRC_REV_1_6));
512 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_4_ONLY, &bdaddr))
513 .WillOnce(Return(false));
514 EXPECT_CALL(*localIopMock, InteropMatchAddr(INTEROP_AVRCP_1_3_ONLY, &bdaddr))
515 .WillOnce(Return(false));
516 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
517 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
518 .WillOnce(DoAll(SetArrayArgument<2>(config_0106, config_0106 + 2), Return(true)));
519 sdpu_set_avrc_target_version(&avrcp_attr, &bdaddr);
520 ASSERT_EQ(get_avrc_target_version(&avrcp_attr), AVRC_REV_1_6);
521 set_avrcp_feat_attr(2, ATTR_ID_SUPPORTED_FEATURES, AVRCP_SUPF_TG_1_5);
522 EXPECT_CALL(btif_config_interface_, GetBinLength(bdaddr.ToString(), _)).WillOnce(Return(2));
523 EXPECT_CALL(btif_config_interface_, GetBin(bdaddr.ToString(), _, _, _))
524 .WillOnce(DoAll(SetArrayArgument<2>(feature_0106, feature_0106 + 2), Return(true)));
525 sdpu_set_avrc_target_features(&avrcp_feat_attr, &bdaddr, get_avrc_target_version(&avrcp_attr));
526 ASSERT_EQ(get_avrc_target_feature(&avrcp_feat_attr),
527 AVRCP_SUPF_TG_1_6 | AVRC_SUPF_TG_PLAYER_COVER_ART);
528 }
529
TEST_F(StackSdpUtilsTest,dynamic_hfp_version_with_invalid_length)530 TEST_F(StackSdpUtilsTest, dynamic_hfp_version_with_invalid_length) {
531 RawAddress bdaddr(RawAddress::kEmpty);
532 set_hfp_attr(INVALID_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_HF_LSB);
533 ASSERT_EQ(sdp_dynamic_change_hfp_version(&hfp_attr, bdaddr), false);
534 }
535
TEST_F(StackSdpUtilsTest,dynamic_hfp_version_with_invalid_UUID)536 TEST_F(StackSdpUtilsTest, dynamic_hfp_version_with_invalid_UUID) {
537 RawAddress bdaddr(RawAddress::kEmpty);
538 set_hfp_attr(SDP_PROFILE_DESC_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, INVALID_UUID);
539 ASSERT_EQ(sdp_dynamic_change_hfp_version(&hfp_attr, bdaddr), false);
540 }
541
TEST_F(StackSdpUtilsTest,check_HFP_version_change_fail)542 TEST_F(StackSdpUtilsTest, check_HFP_version_change_fail) {
543 RawAddress bdaddr(RawAddress::kEmpty);
544 set_hfp_attr(SDP_PROFILE_DESC_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_HF_LSB);
545 test::mock::osi_properties::osi_property_get_bool.body =
546 [](const char* /* key */, bool /* default_value */) { return false; };
547 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_7_ALLOWLIST, &bdaddr,
548 &btif_storage_get_remote_device_property))
549 .WillOnce(Return(false));
550 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_9_ALLOWLIST, &bdaddr,
551 &btif_storage_get_remote_device_property))
552 .WillOnce(Return(false));
553 ASSERT_EQ(sdp_dynamic_change_hfp_version(&hfp_attr, bdaddr), false);
554 }
555
TEST_F(StackSdpUtilsTest,check_HFP_version_change_success)556 TEST_F(StackSdpUtilsTest, check_HFP_version_change_success) {
557 RawAddress bdaddr(RawAddress::kEmpty);
558 set_hfp_attr(SDP_PROFILE_DESC_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_HF_LSB);
559 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_7_ALLOWLIST, &bdaddr,
560 &btif_storage_get_remote_device_property))
561 .WillOnce(Return(true));
562 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_9_ALLOWLIST, &bdaddr,
563 &btif_storage_get_remote_device_property))
564 .WillOnce(Return(true));
565 ASSERT_EQ(sdp_dynamic_change_hfp_version(&hfp_attr, bdaddr), true);
566 }
567
TEST_F(StackSdpUtilsTest,check_HFP_version_fallback_success)568 TEST_F(StackSdpUtilsTest, check_HFP_version_fallback_success) {
569 RawAddress bdaddr(RawAddress::kEmpty);
570 set_hfp_attr(SDP_PROFILE_DESC_LENGTH, ATTR_ID_BT_PROFILE_DESC_LIST, UUID_HF_LSB);
571 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_7_ALLOWLIST, &bdaddr,
572 &btif_storage_get_remote_device_property))
573 .WillOnce(Return(true));
574 EXPECT_CALL(*localIopMock, InteropMatchAddrOrName(INTEROP_HFP_1_9_ALLOWLIST, &bdaddr,
575 &btif_storage_get_remote_device_property))
576 .WillOnce(Return(true));
577 ASSERT_TRUE(sdp_dynamic_change_hfp_version(&hfp_attr, bdaddr));
578 }
579
TEST_F(StackSdpUtilsTest,sdpu_compare_uuid_with_attr_u16)580 TEST_F(StackSdpUtilsTest, sdpu_compare_uuid_with_attr_u16) {
581 tSDP_DISC_ATTR attr = {
582 .p_next_attr = nullptr,
583 .attr_id = 0,
584 .attr_len_type = bluetooth::Uuid::kNumBytes16,
585 .attr_value =
586 {
587 .v =
588 {
589 .u16 = 0x1234,
590 },
591 },
592 };
593
594 bool is_valid{false};
595 bluetooth::Uuid uuid = bluetooth::Uuid::FromString("1234", &is_valid);
596
597 ASSERT_EQ(uuid.As16Bit(), attr.attr_value.v.u16);
598 ASSERT_TRUE(is_valid);
599 ASSERT_TRUE(sdpu_compare_uuid_with_attr(uuid, &attr));
600 }
601
TEST_F(StackSdpUtilsTest,sdpu_compare_uuid_with_attr_u32)602 TEST_F(StackSdpUtilsTest, sdpu_compare_uuid_with_attr_u32) {
603 tSDP_DISC_ATTR attr = {
604 .p_next_attr = nullptr,
605 .attr_id = 0,
606 .attr_len_type = bluetooth::Uuid::kNumBytes32,
607 .attr_value =
608 {
609 .v =
610 {
611 .u32 = 0x12345678,
612 },
613 },
614 };
615
616 bool is_valid{false};
617 bluetooth::Uuid uuid = bluetooth::Uuid::FromString("12345678", &is_valid);
618
619 ASSERT_EQ(uuid.As32Bit(), attr.attr_value.v.u32);
620 ASSERT_TRUE(is_valid);
621 ASSERT_TRUE(sdpu_compare_uuid_with_attr(uuid, &attr));
622 }
623
TEST_F(StackSdpUtilsTest,sdpu_compare_uuid_with_attr_u128)624 TEST_F(StackSdpUtilsTest, sdpu_compare_uuid_with_attr_u128) {
625 tSDP_DISC_ATTR* p_attr = (tSDP_DISC_ATTR*)calloc(1, sizeof(tSDP_DISC_ATTR) + 16);
626 tSDP_DISC_ATTR attr = {
627 .p_next_attr = nullptr,
628 .attr_id = 0,
629 .attr_len_type = bluetooth::Uuid::kNumBytes128,
630 .attr_value = {},
631 };
632
633 uint8_t data[] = {
634 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
635 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
636 };
637
638 memcpy(p_attr, &attr, sizeof(tSDP_DISC_ATTR));
639 memcpy(p_attr->attr_value.v.array, data, 16);
640
641 bool is_valid{false};
642 bluetooth::Uuid uuid =
643 bluetooth::Uuid::FromString("12345678-9abc-def0-1234-56789abcdef0", &is_valid);
644
645 ASSERT_EQ(0, memcmp(uuid.To128BitBE().data(), (void*)p_attr->attr_value.v.array,
646 bluetooth::Uuid::kNumBytes128));
647 ASSERT_TRUE(is_valid);
648 ASSERT_TRUE(sdpu_compare_uuid_with_attr(uuid, p_attr));
649
650 free(p_attr);
651 }
652