1 /*
2  * Copyright 2021 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 
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <sys/socket.h>
20 
21 #include <future>  // NOLINT
22 #include <map>
23 #include <memory>
24 #include <string>
25 
26 #include "bta/include/bta_ag_api.h"
27 #include "bta/include/bta_av_api.h"
28 #include "bta/include/bta_hd_api.h"
29 #include "bta/include/bta_hf_client_api.h"
30 #include "bta/include/bta_hh_api.h"
31 #include "btcore/include/module.h"
32 #include "btif/include/btif_api.h"
33 #include "btif/include/btif_bqr.h"
34 #include "btif/include/btif_common.h"
35 #include "btif/include/btif_jni_task.h"
36 #include "btif/include/btif_sock.h"
37 #include "btif/include/btif_util.h"
38 #include "common/bind.h"
39 #include "common/contextual_callback.h"
40 #include "common/postable_context.h"
41 #include "hci/controller_interface_mock.h"
42 #include "hci/hci_layer_mock.h"
43 #include "include/hardware/bluetooth.h"
44 #include "include/hardware/bt_av.h"
45 #include "packet/base_packet_builder.h"
46 #include "packet/bit_inserter.h"
47 #include "packet/packet_view.h"
48 #include "packet/raw_builder.h"
49 #include "stack/include/bt_uuid16.h"
50 #include "stack/include/main_thread.h"
51 #include "test/common/core_interface.h"
52 #include "test/fake/fake_osi.h"
53 #include "test/mock/mock_main_shim_entry.h"
54 #include "test/mock/mock_osi_properties.h"
55 #include "test/mock/mock_osi_thread.h"
56 #include "test/mock/mock_stack_btm_sec.h"
57 #include "types/bluetooth/uuid.h"
58 #include "types/raw_address.h"
59 
60 // TODO(b/369381361) Enfore -Wmissing-prototypes
61 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
62 
63 namespace bluetooth::testing {
64 void set_hal_cbacks(bt_callbacks_t* callbacks);
65 }  // namespace bluetooth::testing
66 
67 namespace bluetooth::legacy::testing {
68 void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport);
69 void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport, uint16_t acl_handle);
70 }  // namespace bluetooth::legacy::testing
71 
72 const tBTA_AG_RES_DATA tBTA_AG_RES_DATA::kEmpty = {};
73 
74 using bluetooth::Uuid;
75 using bluetooth::common::BindOnce;
76 using bluetooth::common::ContextualCallback;
77 using bluetooth::common::ContextualOnceCallback;
78 using bluetooth::common::PostableContext;
79 using bluetooth::hci::BqrA2dpAudioChoppyEventBuilder;
80 using bluetooth::hci::BqrEventBuilder;
81 using bluetooth::hci::BqrLinkQualityEventBuilder;
82 using bluetooth::hci::BqrLmpLlMessageTraceEventBuilder;
83 using bluetooth::hci::BqrLogDumpEventBuilder;
84 using bluetooth::hci::BqrPacketType;
85 using bluetooth::hci::CommandBuilder;
86 using bluetooth::hci::CommandCompleteBuilder;
87 using bluetooth::hci::CommandCompleteView;
88 using bluetooth::hci::CommandStatusBuilder;
89 using bluetooth::hci::CommandStatusView;
90 using bluetooth::hci::CommandView;
91 using bluetooth::hci::ControllerBqrBuilder;
92 using bluetooth::hci::ControllerBqrCompleteBuilder;
93 using bluetooth::hci::ControllerBqrCompleteView;
94 using bluetooth::hci::ControllerBqrView;
95 using bluetooth::hci::ErrorCode;
96 using bluetooth::hci::EventView;
97 using bluetooth::hci::QualityReportId;
98 using bluetooth::hci::Role;
99 using bluetooth::hci::VendorCommandView;
100 using bluetooth::hci::VendorSpecificEventView;
101 using bluetooth::hci::VseSubeventCode;
102 using bluetooth::packet::BasePacketBuilder;
103 using bluetooth::packet::BitInserter;
104 using bluetooth::packet::kLittleEndian;
105 using bluetooth::packet::PacketView;
106 using bluetooth::packet::RawBuilder;
107 using testing::_;
108 using testing::DoAll;
109 using testing::Invoke;
110 using testing::Matcher;
111 using testing::Return;
112 using testing::SaveArg;
113 
114 module_t bt_utils_module;
115 module_t gd_controller_module;
116 module_t gd_shim_module;
117 module_t osi_module;
118 module_t rust_module;
119 
120 namespace {
121 
BuilderToView(std::unique_ptr<BasePacketBuilder> builder)122 PacketView<kLittleEndian> BuilderToView(std::unique_ptr<BasePacketBuilder> builder) {
123   std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();
124   BitInserter it(*packet_bytes);
125   builder->Serialize(it);
126   return PacketView<kLittleEndian>(packet_bytes);
127 }
128 
129 const RawAddress kRawAddress({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
130 const uint16_t kHciHandle = 123;
131 
132 auto timeout_time = std::chrono::seconds(3);
133 
134 std::map<std::string, std::function<void()>> callback_map_;
135 #define TESTCB                                             \
136   if (callback_map_.find(__func__) != callback_map_.end()) \
137     callback_map_[__func__]();
138 
adapter_state_changed_callback(bt_state_t)139 void adapter_state_changed_callback(bt_state_t /* state */) {}
adapter_properties_callback(bt_status_t,int,bt_property_t *)140 void adapter_properties_callback(bt_status_t /* status */, int /* num_properties */,
141                                  bt_property_t* /* properties */) {}
remote_device_properties_callback(bt_status_t,RawAddress *,int,bt_property_t *)142 void remote_device_properties_callback(bt_status_t /* status */, RawAddress* /* bd_addr */,
143                                        int /* num_properties */, bt_property_t* /* properties */) {}
device_found_callback(int,bt_property_t *)144 void device_found_callback(int /* num_properties */, bt_property_t* /* properties */) {}
discovery_state_changed_callback(bt_discovery_state_t)145 void discovery_state_changed_callback(bt_discovery_state_t /* state */) {}
pin_request_callback(RawAddress *,bt_bdname_t *,uint32_t,bool)146 void pin_request_callback(RawAddress* /* remote_bd_addr */, bt_bdname_t* /* bd_name */,
147                           uint32_t /* cod */, bool /* min_16_digit */) {}
ssp_request_callback(RawAddress *,bt_ssp_variant_t,uint32_t)148 void ssp_request_callback(RawAddress* /* remote_bd_addr */, bt_ssp_variant_t /* pairing_variant */,
149                           uint32_t /* pass_key */) {}
bond_state_changed_callback(bt_status_t,RawAddress *,bt_bond_state_t,int)150 void bond_state_changed_callback(bt_status_t /* status */, RawAddress* /* remote_bd_addr */,
151                                  bt_bond_state_t /* state */, int /* fail_reason */) {}
address_consolidate_callback(RawAddress *,RawAddress *)152 void address_consolidate_callback(RawAddress* /* main_bd_addr */,
153                                   RawAddress* /* secondary_bd_addr */) {}
le_address_associate_callback(RawAddress *,RawAddress *,uint8_t)154 void le_address_associate_callback(RawAddress* /* main_bd_addr */,
155                                    RawAddress* /* secondary_bd_addr */,
156                                    uint8_t /* identity_address_type */) {}
acl_state_changed_callback(bt_status_t,RawAddress *,bt_acl_state_t,int,bt_hci_error_code_t,bt_conn_direction_t,uint16_t)157 void acl_state_changed_callback(bt_status_t /* status */, RawAddress* /* remote_bd_addr */,
158                                 bt_acl_state_t /* state */, int /* transport_link_type */,
159                                 bt_hci_error_code_t /* hci_reason */,
160                                 bt_conn_direction_t /* direction */, uint16_t /* acl_handle */) {}
link_quality_report_callback(uint64_t,int,int,int,int,int,int)161 void link_quality_report_callback(uint64_t /* timestamp */, int /* report_id */, int /* rssi */,
162                                   int /* snr */, int /* retransmission_count */,
163                                   int /* packets_not_receive_count */,
164                                   int /* negative_acknowledgement_count */) {
165   TESTCB;
166 }
callback_thread_event(bt_cb_thread_evt)167 void callback_thread_event(bt_cb_thread_evt /* evt */) { TESTCB; }
dut_mode_recv_callback(uint16_t,uint8_t *,uint8_t)168 void dut_mode_recv_callback(uint16_t /* opcode */, uint8_t* /* buf */, uint8_t /* len */) {}
le_test_mode_callback(bt_status_t,uint16_t)169 void le_test_mode_callback(bt_status_t /* status */, uint16_t /* num_packets */) {}
energy_info_callback(bt_activity_energy_info *,bt_uid_traffic_t *)170 void energy_info_callback(bt_activity_energy_info* /* energy_info */,
171                           bt_uid_traffic_t* /* uid_data */) {}
generate_local_oob_data_callback(tBT_TRANSPORT,bt_oob_data_t)172 void generate_local_oob_data_callback(tBT_TRANSPORT /* transport */, bt_oob_data_t /* oob_data */) {
173 }
switch_buffer_size_callback(bool)174 void switch_buffer_size_callback(bool /* is_low_latency_buffer_size */) {}
switch_codec_callback(bool)175 void switch_codec_callback(bool /* is_low_latency_buffer_size */) {}
le_rand_callback(uint64_t)176 void le_rand_callback(uint64_t /* random */) {}
key_missing_callback(const RawAddress)177 void key_missing_callback(const RawAddress /* bd_addr */) {}
178 #undef TESTCB
179 
180 bt_callbacks_t callbacks = {
181         .size = sizeof(bt_callbacks_t),
182         .adapter_state_changed_cb = adapter_state_changed_callback,
183         .adapter_properties_cb = adapter_properties_callback,
184         .remote_device_properties_cb = remote_device_properties_callback,
185         .device_found_cb = device_found_callback,
186         .discovery_state_changed_cb = discovery_state_changed_callback,
187         .pin_request_cb = pin_request_callback,
188         .ssp_request_cb = ssp_request_callback,
189         .bond_state_changed_cb = bond_state_changed_callback,
190         .address_consolidate_cb = address_consolidate_callback,
191         .le_address_associate_cb = le_address_associate_callback,
192         .acl_state_changed_cb = acl_state_changed_callback,
193         .thread_evt_cb = callback_thread_event,
194         .dut_mode_recv_cb = dut_mode_recv_callback,
195         .le_test_mode_cb = le_test_mode_callback,
196         .energy_info_cb = energy_info_callback,
197         .link_quality_report_cb = link_quality_report_callback,
198         .generate_local_oob_data_cb = generate_local_oob_data_callback,
199         .switch_buffer_size_cb = switch_buffer_size_callback,
200         .switch_codec_cb = switch_codec_callback,
201         .le_rand_cb = le_rand_callback,
202         .key_missing_cb = key_missing_callback,
203 };
204 
205 }  // namespace
206 
207 class BtifUtilsTest : public ::testing::Test {};
208 
209 class BtifCoreTest : public ::testing::Test {
210 protected:
SetUp()211   void SetUp() override {
212     callback_map_.clear();
213     bluetooth::hci::testing::mock_controller_ = &controller_;
214     bluetooth::testing::set_hal_cbacks(&callbacks);
215     auto promise = std::promise<void>();
216     auto future = promise.get_future();
217     callback_map_["callback_thread_event"] = [&promise]() { promise.set_value(); };
218     InitializeCoreInterface();
219     ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
220     callback_map_.erase("callback_thread_event");
221   }
222 
TearDown()223   void TearDown() override {
224     auto promise = std::promise<void>();
225     auto future = promise.get_future();
226     callback_map_["callback_thread_event"] = [&promise]() { promise.set_value(); };
227     CleanCoreInterface();
228     ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
229     bluetooth::hci::testing::mock_controller_ = nullptr;
230     callback_map_.erase("callback_thread_event");
231   }
232   bluetooth::hci::testing::MockControllerInterface controller_;
233 };
234 
235 class BtifCoreWithControllerTest : public BtifCoreTest {
236 protected:
SetUp()237   void SetUp() override {
238     BtifCoreTest::SetUp();
239     ON_CALL(controller_, SupportsSniffSubrating).WillByDefault(Return(true));
240   }
241 
TearDown()242   void TearDown() override { BtifCoreTest::TearDown(); }
243 };
244 
245 class BtifCoreWithConnectionTest : public BtifCoreWithControllerTest {
246 protected:
SetUp()247   void SetUp() override {
248     BtifCoreWithControllerTest::SetUp();
249     bluetooth::legacy::testing::bta_dm_acl_up(kRawAddress, BT_TRANSPORT_AUTO, kHciHandle);
250   }
251 
TearDown()252   void TearDown() override {
253     bluetooth::legacy::testing::bta_dm_acl_down(kRawAddress, BT_TRANSPORT_AUTO);
254     BtifCoreWithControllerTest::TearDown();
255   }
256 };
257 
258 std::promise<int> promise0;
callback0(int val)259 void callback0(int val) { promise0.set_value(val); }
260 
TEST_F(BtifCoreTest,test_nop)261 TEST_F(BtifCoreTest, test_nop) {}
262 
TEST_F(BtifCoreTest,test_post_on_bt_simple0)263 TEST_F(BtifCoreTest, test_post_on_bt_simple0) {
264   const int val = kHciHandle;
265   promise0 = std::promise<int>();
266   std::future<int> future0 = promise0.get_future();
267   post_on_bt_jni([=]() { callback0(val); });
268   ASSERT_EQ(std::future_status::ready, future0.wait_for(timeout_time));
269   ASSERT_EQ(val, future0.get());
270 }
271 
TEST_F(BtifCoreTest,test_post_on_bt_jni_simple1)272 TEST_F(BtifCoreTest, test_post_on_bt_jni_simple1) {
273   std::promise<void> promise;
274   std::future<void> future = promise.get_future();
275   post_on_bt_jni([=, &promise]() { promise.set_value(); });
276   ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
277 }
278 
TEST_F(BtifCoreTest,test_post_on_bt_jni_simple2)279 TEST_F(BtifCoreTest, test_post_on_bt_jni_simple2) {
280   std::promise<void> promise;
281   std::future<void> future = promise.get_future();
282   BtJniClosure closure = [&promise]() { promise.set_value(); };
283   post_on_bt_jni(closure);
284   ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
285 }
286 
TEST_F(BtifCoreTest,test_post_on_bt_jni_simple3)287 TEST_F(BtifCoreTest, test_post_on_bt_jni_simple3) {
288   const int val = 456;
289   std::promise<int> promise;
290   auto future = promise.get_future();
291   BtJniClosure closure = [&promise, val]() { promise.set_value(val); };
292   post_on_bt_jni(closure);
293   ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
294   ASSERT_EQ(val, future.get());
295 }
296 
TEST_F(BtifUtilsTest,dump_dm_search_event)297 TEST_F(BtifUtilsTest, dump_dm_search_event) {
298   std::vector<std::pair<uint16_t, std::string>> events = {
299           std::make_pair(BTA_DM_INQ_RES_EVT, "BTA_DM_INQ_RES_EVT"),
300           std::make_pair(BTA_DM_INQ_CMPL_EVT, "BTA_DM_INQ_CMPL_EVT"),
301           std::make_pair(BTA_DM_DISC_CMPL_EVT, "BTA_DM_DISC_CMPL_EVT"),
302           std::make_pair(BTA_DM_SEARCH_CANCEL_CMPL_EVT, "BTA_DM_SEARCH_CANCEL_CMPL_EVT"),
303           std::make_pair(BTA_DM_NAME_READ_EVT, "BTA_DM_NAME_READ_EVT"),
304   };
305   for (const auto& event : events) {
306     ASSERT_TRUE(dump_dm_search_event(event.first).starts_with(event.second));
307   }
308   ASSERT_TRUE(dump_dm_search_event(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
309 }
310 
TEST_F(BtifUtilsTest,dump_property_type)311 TEST_F(BtifUtilsTest, dump_property_type) {
312   std::vector<std::pair<bt_property_type_t, std::string>> types = {
313           std::make_pair(BT_PROPERTY_BDNAME, "BT_PROPERTY_BDNAME"),
314           std::make_pair(BT_PROPERTY_BDADDR, "BT_PROPERTY_BDADDR"),
315           std::make_pair(BT_PROPERTY_UUIDS, "BT_PROPERTY_UUIDS"),
316           std::make_pair(BT_PROPERTY_CLASS_OF_DEVICE, "BT_PROPERTY_CLASS_OF_DEVICE"),
317           std::make_pair(BT_PROPERTY_TYPE_OF_DEVICE, "BT_PROPERTY_TYPE_OF_DEVICE"),
318           std::make_pair(BT_PROPERTY_REMOTE_RSSI, "BT_PROPERTY_REMOTE_RSSI"),
319           std::make_pair(BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT,
320                          "BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT"),
321           std::make_pair(BT_PROPERTY_ADAPTER_BONDED_DEVICES, "BT_PROPERTY_ADAPTER_BONDED_DEVICES"),
322           std::make_pair(BT_PROPERTY_REMOTE_FRIENDLY_NAME, "BT_PROPERTY_REMOTE_FRIENDLY_NAME"),
323   };
324   for (const auto& type : types) {
325     EXPECT_TRUE(dump_property_type(type.first).starts_with(type.second));
326   }
327   EXPECT_TRUE(
328           dump_property_type(static_cast<bt_property_type_t>(std::numeric_limits<uint16_t>::max()))
329                   .starts_with("Unknown"));
330 }
331 
TEST_F(BtifUtilsTest,dump_dm_event)332 TEST_F(BtifUtilsTest, dump_dm_event) {
333   std::vector<std::pair<uint8_t, std::string>> events = {
334           std::make_pair(BTA_DM_PIN_REQ_EVT, "BTA_DM_PIN_REQ_EVT"),
335           std::make_pair(BTA_DM_AUTH_CMPL_EVT, "BTA_DM_AUTH_CMPL_EVT"),
336           std::make_pair(BTA_DM_LINK_UP_EVT, "BTA_DM_LINK_UP_EVT"),
337           std::make_pair(BTA_DM_LINK_DOWN_EVT, "BTA_DM_LINK_DOWN_EVT"),
338           std::make_pair(BTA_DM_BOND_CANCEL_CMPL_EVT, "BTA_DM_BOND_CANCEL_CMPL_EVT"),
339           std::make_pair(BTA_DM_SP_CFM_REQ_EVT, "BTA_DM_SP_CFM_REQ_EVT"),
340           std::make_pair(BTA_DM_SP_KEY_NOTIF_EVT, "BTA_DM_SP_KEY_NOTIF_EVT"),
341           std::make_pair(BTA_DM_BLE_KEY_EVT, "BTA_DM_BLE_KEY_EVT"),
342           std::make_pair(BTA_DM_BLE_SEC_REQ_EVT, "BTA_DM_BLE_SEC_REQ_EVT"),
343           std::make_pair(BTA_DM_BLE_PASSKEY_NOTIF_EVT, "BTA_DM_BLE_PASSKEY_NOTIF_EVT"),
344           std::make_pair(BTA_DM_BLE_PASSKEY_REQ_EVT, "BTA_DM_BLE_PASSKEY_REQ_EVT"),
345           std::make_pair(BTA_DM_BLE_OOB_REQ_EVT, "BTA_DM_BLE_OOB_REQ_EVT"),
346           std::make_pair(BTA_DM_BLE_SC_OOB_REQ_EVT, "BTA_DM_BLE_SC_OOB_REQ_EVT"),
347           std::make_pair(BTA_DM_BLE_LOCAL_IR_EVT, "BTA_DM_BLE_LOCAL_IR_EVT"),
348           std::make_pair(BTA_DM_BLE_LOCAL_ER_EVT, "BTA_DM_BLE_LOCAL_ER_EVT"),
349           std::make_pair(BTA_DM_BLE_AUTH_CMPL_EVT, "BTA_DM_BLE_AUTH_CMPL_EVT"),
350           std::make_pair(BTA_DM_DEV_UNPAIRED_EVT, "BTA_DM_DEV_UNPAIRED_EVT"),
351           std::make_pair(BTA_DM_ENER_INFO_READ, "BTA_DM_ENER_INFO_READ"),
352   };
353   for (const auto& event : events) {
354     ASSERT_TRUE(dump_dm_event(event.first).starts_with(event.second));
355   }
356   ASSERT_TRUE(dump_dm_event(std::numeric_limits<uint8_t>::max()).starts_with("Unknown"));
357 }
358 
TEST_F(BtifUtilsTest,dump_hf_event)359 TEST_F(BtifUtilsTest, dump_hf_event) {
360   std::vector<std::pair<uint8_t, std::string>> events = {
361           std::make_pair(BTA_AG_ENABLE_EVT, "BTA_AG_ENABLE_EVT"),
362           std::make_pair(BTA_AG_REGISTER_EVT, "BTA_AG_REGISTER_EVT"),
363           std::make_pair(BTA_AG_OPEN_EVT, "BTA_AG_OPEN_EVT"),
364           std::make_pair(BTA_AG_CLOSE_EVT, "BTA_AG_CLOSE_EVT"),
365           std::make_pair(BTA_AG_CONN_EVT, "BTA_AG_CONN_EVT"),
366           std::make_pair(BTA_AG_AUDIO_OPEN_EVT, "BTA_AG_AUDIO_OPEN_EVT"),
367           std::make_pair(BTA_AG_AUDIO_CLOSE_EVT, "BTA_AG_AUDIO_CLOSE_EVT"),
368           std::make_pair(BTA_AG_SPK_EVT, "BTA_AG_SPK_EVT"),
369           std::make_pair(BTA_AG_MIC_EVT, "BTA_AG_MIC_EVT"),
370           std::make_pair(BTA_AG_AT_CKPD_EVT, "BTA_AG_AT_CKPD_EVT"),
371           std::make_pair(BTA_AG_DISABLE_EVT, "BTA_AG_DISABLE_EVT"),
372           std::make_pair(BTA_AG_CODEC_EVT, "BTA_AG_CODEC_EVT"),
373           std::make_pair(BTA_AG_AT_A_EVT, "BTA_AG_AT_A_EVT"),
374           std::make_pair(BTA_AG_AT_D_EVT, "BTA_AG_AT_D_EVT"),
375           std::make_pair(BTA_AG_AT_CHLD_EVT, "BTA_AG_AT_CHLD_EVT"),
376           std::make_pair(BTA_AG_AT_CHUP_EVT, "BTA_AG_AT_CHUP_EVT"),
377           std::make_pair(BTA_AG_AT_CIND_EVT, "BTA_AG_AT_CIND_EVT"),
378           std::make_pair(BTA_AG_AT_VTS_EVT, "BTA_AG_AT_VTS_EVT"),
379           std::make_pair(BTA_AG_AT_BINP_EVT, "BTA_AG_AT_BINP_EVT"),
380           std::make_pair(BTA_AG_AT_BLDN_EVT, "BTA_AG_AT_BLDN_EVT"),
381           std::make_pair(BTA_AG_AT_BVRA_EVT, "BTA_AG_AT_BVRA_EVT"),
382           std::make_pair(BTA_AG_AT_NREC_EVT, "BTA_AG_AT_NREC_EVT"),
383           std::make_pair(BTA_AG_AT_CNUM_EVT, "BTA_AG_AT_CNUM_EVT"),
384           std::make_pair(BTA_AG_AT_BTRH_EVT, "BTA_AG_AT_BTRH_EVT"),
385           std::make_pair(BTA_AG_AT_CLCC_EVT, "BTA_AG_AT_CLCC_EVT"),
386           std::make_pair(BTA_AG_AT_COPS_EVT, "BTA_AG_AT_COPS_EVT"),
387           std::make_pair(BTA_AG_AT_UNAT_EVT, "BTA_AG_AT_UNAT_EVT"),
388           std::make_pair(BTA_AG_AT_CBC_EVT, "BTA_AG_AT_CBC_EVT"),
389           std::make_pair(BTA_AG_AT_BAC_EVT, "BTA_AG_AT_BAC_EVT"),
390           std::make_pair(BTA_AG_AT_BCS_EVT, "BTA_AG_AT_BCS_EVT"),
391           std::make_pair(BTA_AG_AT_BIND_EVT, "BTA_AG_AT_BIND_EVT"),
392           std::make_pair(BTA_AG_AT_BIEV_EVT, "BTA_AG_AT_BIEV_EVT"),
393           std::make_pair(BTA_AG_AT_BIA_EVT, "BTA_AG_AT_BIA_EVT"),
394   };
395   for (const auto& event : events) {
396     ASSERT_TRUE(dump_hf_event(event.first).starts_with(event.second));
397   }
398   ASSERT_TRUE(dump_hf_event(std::numeric_limits<uint8_t>::max()).starts_with("Unknown"));
399 }
400 
TEST_F(BtifUtilsTest,dump_hf_client_event)401 TEST_F(BtifUtilsTest, dump_hf_client_event) {
402   std::vector<std::pair<int, std::string>> events = {
403           std::make_pair(BTA_HF_CLIENT_ENABLE_EVT, "BTA_HF_CLIENT_ENABLE_EVT"),
404           std::make_pair(BTA_HF_CLIENT_REGISTER_EVT, "BTA_HF_CLIENT_REGISTER_EVT"),
405           std::make_pair(BTA_HF_CLIENT_OPEN_EVT, "BTA_HF_CLIENT_OPEN_EVT"),
406           std::make_pair(BTA_HF_CLIENT_CLOSE_EVT, "BTA_HF_CLIENT_CLOSE_EVT"),
407           std::make_pair(BTA_HF_CLIENT_CONN_EVT, "BTA_HF_CLIENT_CONN_EVT"),
408           std::make_pair(BTA_HF_CLIENT_AUDIO_OPEN_EVT, "BTA_HF_CLIENT_AUDIO_OPEN_EVT"),
409           std::make_pair(BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT, "BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT"),
410           std::make_pair(BTA_HF_CLIENT_AUDIO_LC3_OPEN_EVT, "BTA_HF_CLIENT_AUDIO_LC3_OPEN_EVT"),
411           std::make_pair(BTA_HF_CLIENT_AUDIO_CLOSE_EVT, "BTA_HF_CLIENT_AUDIO_CLOSE_EVT"),
412           std::make_pair(BTA_HF_CLIENT_SPK_EVT, "BTA_HF_CLIENT_SPK_EVT"),
413           std::make_pair(BTA_HF_CLIENT_MIC_EVT, "BTA_HF_CLIENT_MIC_EVT"),
414           std::make_pair(BTA_HF_CLIENT_DISABLE_EVT, "BTA_HF_CLIENT_DISABLE_EVT"),
415           std::make_pair(BTA_HF_CLIENT_IND_EVT, "BTA_HF_CLIENT_IND_EVT"),
416           std::make_pair(BTA_HF_CLIENT_VOICE_REC_EVT, "BTA_HF_CLIENT_VOICE_REC_EVT"),
417           std::make_pair(BTA_HF_CLIENT_OPERATOR_NAME_EVT, "BTA_HF_CLIENT_OPERATOR_NAME_EVT"),
418           std::make_pair(BTA_HF_CLIENT_CLIP_EVT, "BTA_HF_CLIENT_CLIP_EVT"),
419           std::make_pair(BTA_HF_CLIENT_CCWA_EVT, "BTA_HF_CLIENT_CCWA_EVT"),
420           std::make_pair(BTA_HF_CLIENT_AT_RESULT_EVT, "BTA_HF_CLIENT_AT_RESULT_EVT"),
421           std::make_pair(BTA_HF_CLIENT_CLCC_EVT, "BTA_HF_CLIENT_CLCC_EVT"),
422           std::make_pair(BTA_HF_CLIENT_CNUM_EVT, "BTA_HF_CLIENT_CNUM_EVT"),
423           std::make_pair(BTA_HF_CLIENT_BTRH_EVT, "BTA_HF_CLIENT_BTRH_EVT"),
424           std::make_pair(BTA_HF_CLIENT_BSIR_EVT, "BTA_HF_CLIENT_BSIR_EVT"),
425           std::make_pair(BTA_HF_CLIENT_BINP_EVT, "BTA_HF_CLIENT_BINP_EVT"),
426           std::make_pair(BTA_HF_CLIENT_RING_INDICATION, "BTA_HF_CLIENT_RING_INDICATION"),
427   };
428   for (const auto& event : events) {
429     ASSERT_TRUE(dump_hf_client_event(event.first).starts_with(event.second));
430   }
431   ASSERT_TRUE(dump_hf_client_event(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
432 }
433 
TEST_F(BtifCoreTest,bta_hh_event_text)434 TEST_F(BtifCoreTest, bta_hh_event_text) {
435   std::vector<std::pair<int, std::string>> events = {
436           std::make_pair(BTA_HH_EMPTY_EVT, "BTA_HH_EMPTY_EVT"),
437           std::make_pair(BTA_HH_ENABLE_EVT, "BTA_HH_ENABLE_EVT"),
438           std::make_pair(BTA_HH_DISABLE_EVT, "BTA_HH_DISABLE_EVT"),
439           std::make_pair(BTA_HH_OPEN_EVT, "BTA_HH_OPEN_EVT"),
440           std::make_pair(BTA_HH_CLOSE_EVT, "BTA_HH_CLOSE_EVT"),
441           std::make_pair(BTA_HH_GET_DSCP_EVT, "BTA_HH_GET_DSCP_EVT"),
442           std::make_pair(BTA_HH_GET_PROTO_EVT, "BTA_HH_GET_PROTO_EVT"),
443           std::make_pair(BTA_HH_GET_RPT_EVT, "BTA_HH_GET_RPT_EVT"),
444           std::make_pair(BTA_HH_GET_IDLE_EVT, "BTA_HH_GET_IDLE_EVT"),
445           std::make_pair(BTA_HH_SET_PROTO_EVT, "BTA_HH_SET_PROTO_EVT"),
446           std::make_pair(BTA_HH_SET_RPT_EVT, "BTA_HH_SET_RPT_EVT"),
447           std::make_pair(BTA_HH_SET_IDLE_EVT, "BTA_HH_SET_IDLE_EVT"),
448           std::make_pair(BTA_HH_VC_UNPLUG_EVT, "BTA_HH_VC_UNPLUG_EVT"),
449           std::make_pair(BTA_HH_ADD_DEV_EVT, "BTA_HH_ADD_DEV_EVT"),
450           std::make_pair(BTA_HH_RMV_DEV_EVT, "BTA_HH_RMV_DEV_EVT"),
451           std::make_pair(BTA_HH_API_ERR_EVT, "BTA_HH_API_ERR_EVT"),
452   };
453   for (const auto& event : events) {
454     ASSERT_TRUE(bta_hh_event_text(event.first).starts_with(event.second));
455   }
456   ASSERT_TRUE(bta_hh_event_text(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
457 }
458 
TEST_F(BtifUtilsTest,dump_hd_event)459 TEST_F(BtifUtilsTest, dump_hd_event) {
460   std::vector<std::pair<uint16_t, std::string>> events = {
461           std::make_pair(BTA_HD_ENABLE_EVT, "BTA_HD_ENABLE_EVT"),
462           std::make_pair(BTA_HD_DISABLE_EVT, "BTA_HD_DISABLE_EVT"),
463           std::make_pair(BTA_HD_REGISTER_APP_EVT, "BTA_HD_REGISTER_APP_EVT"),
464           std::make_pair(BTA_HD_UNREGISTER_APP_EVT, "BTA_HD_UNREGISTER_APP_EVT"),
465           std::make_pair(BTA_HD_OPEN_EVT, "BTA_HD_OPEN_EVT"),
466           std::make_pair(BTA_HD_CLOSE_EVT, "BTA_HD_CLOSE_EVT"),
467           std::make_pair(BTA_HD_GET_REPORT_EVT, "BTA_HD_GET_REPORT_EVT"),
468           std::make_pair(BTA_HD_SET_REPORT_EVT, "BTA_HD_SET_REPORT_EVT"),
469           std::make_pair(BTA_HD_SET_PROTOCOL_EVT, "BTA_HD_SET_PROTOCOL_EVT"),
470           std::make_pair(BTA_HD_INTR_DATA_EVT, "BTA_HD_INTR_DATA_EVT"),
471           std::make_pair(BTA_HD_VC_UNPLUG_EVT, "BTA_HD_VC_UNPLUG_EVT"),
472           std::make_pair(BTA_HD_CONN_STATE_EVT, "BTA_HD_CONN_STATE_EVT"),
473           std::make_pair(BTA_HD_API_ERR_EVT, "BTA_HD_API_ERR_EVT"),
474   };
475   for (const auto& event : events) {
476     ASSERT_TRUE(dump_hd_event(event.first).starts_with(event.second));
477   }
478   ASSERT_TRUE(dump_hd_event(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
479 }
480 
TEST_F(BtifUtilsTest,dump_thread_evt)481 TEST_F(BtifUtilsTest, dump_thread_evt) {
482   std::vector<std::pair<bt_cb_thread_evt, std::string>> events = {
483           std::make_pair(ASSOCIATE_JVM, "ASSOCIATE_JVM"),
484           std::make_pair(DISASSOCIATE_JVM, "DISASSOCIATE_JVM"),
485   };
486   for (const auto& event : events) {
487     ASSERT_TRUE(dump_thread_evt(event.first).starts_with(event.second));
488   }
489   ASSERT_TRUE(dump_thread_evt(static_cast<bt_cb_thread_evt>(std::numeric_limits<uint16_t>::max()))
490                       .starts_with("Unknown"));
491 }
492 
TEST_F(BtifUtilsTest,dump_av_conn_state)493 TEST_F(BtifUtilsTest, dump_av_conn_state) {
494   std::vector<std::pair<uint16_t, std::string>> events = {
495           std::make_pair(BTAV_CONNECTION_STATE_DISCONNECTED, "BTAV_CONNECTION_STATE_DISCONNECTED"),
496           std::make_pair(BTAV_CONNECTION_STATE_CONNECTING, "BTAV_CONNECTION_STATE_CONNECTING"),
497           std::make_pair(BTAV_CONNECTION_STATE_CONNECTED, "BTAV_CONNECTION_STATE_CONNECTED"),
498           std::make_pair(BTAV_CONNECTION_STATE_DISCONNECTING,
499                          "BTAV_CONNECTION_STATE_DISCONNECTING"),
500   };
501   for (const auto& event : events) {
502     ASSERT_TRUE(dump_av_conn_state(event.first).starts_with(event.second));
503   }
504   ASSERT_TRUE(dump_av_conn_state(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
505 }
506 
TEST_F(BtifUtilsTest,dump_av_audio_state)507 TEST_F(BtifUtilsTest, dump_av_audio_state) {
508   std::vector<std::pair<uint16_t, std::string>> events = {
509           std::make_pair(BTAV_AUDIO_STATE_REMOTE_SUSPEND, "BTAV_AUDIO_STATE_REMOTE_SUSPEND"),
510           std::make_pair(BTAV_AUDIO_STATE_STOPPED, "BTAV_AUDIO_STATE_STOPPED"),
511           std::make_pair(BTAV_AUDIO_STATE_STARTED, "BTAV_AUDIO_STATE_STARTED"),
512   };
513   for (const auto& event : events) {
514     ASSERT_TRUE(dump_av_audio_state(event.first).starts_with(event.second));
515   }
516   ASSERT_TRUE(dump_av_audio_state(std::numeric_limits<uint16_t>::max()).starts_with("Unknown"));
517 }
518 
TEST_F(BtifUtilsTest,dump_adapter_scan_mode)519 TEST_F(BtifUtilsTest, dump_adapter_scan_mode) {
520   std::vector<std::pair<bt_scan_mode_t, std::string>> events = {
521           std::make_pair(BT_SCAN_MODE_NONE, "BT_SCAN_MODE_NONE"),
522           std::make_pair(BT_SCAN_MODE_CONNECTABLE, "BT_SCAN_MODE_CONNECTABLE"),
523           std::make_pair(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE,
524                          "BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE"),
525   };
526   for (const auto& event : events) {
527     ASSERT_TRUE(dump_adapter_scan_mode(event.first).starts_with(event.second));
528   }
529   ASSERT_TRUE(dump_adapter_scan_mode(static_cast<bt_scan_mode_t>(std::numeric_limits<int>::max()))
530                       .starts_with("Unknown"));
531 }
532 
TEST_F(BtifUtilsTest,dump_bt_status)533 TEST_F(BtifUtilsTest, dump_bt_status) {
534   std::vector<std::pair<bt_status_t, std::string>> events = {
535           std::make_pair(BT_STATUS_SUCCESS, "BT_STATUS_SUCCESS"),
536           std::make_pair(BT_STATUS_FAIL, "BT_STATUS_FAIL"),
537           std::make_pair(BT_STATUS_NOT_READY, "BT_STATUS_NOT_READY"),
538           std::make_pair(BT_STATUS_NOMEM, "BT_STATUS_NOMEM"),
539           std::make_pair(BT_STATUS_BUSY, "BT_STATUS_BUSY"),
540           std::make_pair(BT_STATUS_UNSUPPORTED, "BT_STATUS_UNSUPPORTED"),
541   };
542   for (const auto& event : events) {
543     ASSERT_TRUE(dump_bt_status(event.first).starts_with(event.second));
544   }
545   ASSERT_TRUE(dump_bt_status(static_cast<bt_status_t>(std::numeric_limits<int>::max()))
546                       .starts_with("Unknown"));
547 }
548 
TEST_F(BtifUtilsTest,dump_rc_event)549 TEST_F(BtifUtilsTest, dump_rc_event) {
550   std::vector<std::pair<uint8_t, std::string>> events = {
551           std::make_pair(BTA_AV_RC_OPEN_EVT, "BTA_AV_RC_OPEN_EVT"),
552           std::make_pair(BTA_AV_RC_CLOSE_EVT, "BTA_AV_RC_CLOSE_EVT"),
553           std::make_pair(BTA_AV_RC_BROWSE_OPEN_EVT, "BTA_AV_RC_BROWSE_OPEN_EVT"),
554           std::make_pair(BTA_AV_RC_BROWSE_CLOSE_EVT, "BTA_AV_RC_BROWSE_CLOSE_EVT"),
555           std::make_pair(BTA_AV_REMOTE_CMD_EVT, "BTA_AV_REMOTE_CMD_EVT"),
556           std::make_pair(BTA_AV_REMOTE_RSP_EVT, "BTA_AV_REMOTE_RSP_EVT"),
557           std::make_pair(BTA_AV_VENDOR_CMD_EVT, "BTA_AV_VENDOR_CMD_EVT"),
558           std::make_pair(BTA_AV_VENDOR_RSP_EVT, "BTA_AV_VENDOR_RSP_EVT"),
559           std::make_pair(BTA_AV_META_MSG_EVT, "BTA_AV_META_MSG_EVT"),
560           std::make_pair(BTA_AV_RC_FEAT_EVT, "BTA_AV_RC_FEAT_EVT"),
561           std::make_pair(BTA_AV_RC_PSM_EVT, "BTA_AV_RC_PSM_EVT"),
562   };
563   for (const auto& event : events) {
564     ASSERT_TRUE(dump_rc_event(event.first).starts_with(event.second));
565   }
566   ASSERT_TRUE(dump_rc_event(std::numeric_limits<uint8_t>::max()).starts_with("Unknown"));
567 }
568 
TEST_F(BtifUtilsTest,dump_rc_notification_event_id)569 TEST_F(BtifUtilsTest, dump_rc_notification_event_id) {
570   std::vector<std::pair<uint8_t, std::string>> events = {
571           std::make_pair(AVRC_EVT_PLAY_STATUS_CHANGE, "AVRC_EVT_PLAY_STATUS_CHANGE"),
572           std::make_pair(AVRC_EVT_TRACK_CHANGE, "AVRC_EVT_TRACK_CHANGE"),
573           std::make_pair(AVRC_EVT_TRACK_REACHED_END, "AVRC_EVT_TRACK_REACHED_END"),
574           std::make_pair(AVRC_EVT_TRACK_REACHED_START, "AVRC_EVT_TRACK_REACHED_START"),
575           std::make_pair(AVRC_EVT_PLAY_POS_CHANGED, "AVRC_EVT_PLAY_POS_CHANGED"),
576           std::make_pair(AVRC_EVT_BATTERY_STATUS_CHANGE, "AVRC_EVT_BATTERY_STATUS_CHANGE"),
577           std::make_pair(AVRC_EVT_SYSTEM_STATUS_CHANGE, "AVRC_EVT_SYSTEM_STATUS_CHANGE"),
578           std::make_pair(AVRC_EVT_APP_SETTING_CHANGE, "AVRC_EVT_APP_SETTING_CHANGE"),
579           std::make_pair(AVRC_EVT_VOLUME_CHANGE, "AVRC_EVT_VOLUME_CHANGE"),
580           std::make_pair(AVRC_EVT_ADDR_PLAYER_CHANGE, "AVRC_EVT_ADDR_PLAYER_CHANGE"),
581           std::make_pair(AVRC_EVT_AVAL_PLAYERS_CHANGE, "AVRC_EVT_AVAL_PLAYERS_CHANGE"),
582           std::make_pair(AVRC_EVT_NOW_PLAYING_CHANGE, "AVRC_EVT_NOW_PLAYING_CHANGE"),
583           std::make_pair(AVRC_EVT_UIDS_CHANGE, "AVRC_EVT_UIDS_CHANGE"),
584   };
585   for (const auto& event : events) {
586     ASSERT_TRUE(dump_rc_notification_event_id(event.first).starts_with(event.second));
587   }
588   ASSERT_TRUE(dump_rc_notification_event_id(std::numeric_limits<uint8_t>::max())
589                       .starts_with("Unknown"));
590 }
591 
TEST_F(BtifUtilsTest,dump_rc_pdu)592 TEST_F(BtifUtilsTest, dump_rc_pdu) {
593   std::vector<std::pair<uint8_t, std::string>> pdus = {
594           std::make_pair(AVRC_PDU_LIST_PLAYER_APP_ATTR, "AVRC_PDU_LIST_PLAYER_APP_ATTR"),
595           std::make_pair(AVRC_PDU_LIST_PLAYER_APP_VALUES, "AVRC_PDU_LIST_PLAYER_APP_VALUES"),
596           std::make_pair(AVRC_PDU_GET_CUR_PLAYER_APP_VALUE, "AVRC_PDU_GET_CUR_PLAYER_APP_VALUE"),
597           std::make_pair(AVRC_PDU_SET_PLAYER_APP_VALUE, "AVRC_PDU_SET_PLAYER_APP_VALUE"),
598           std::make_pair(AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT, "AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT"),
599           std::make_pair(AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT, "AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT"),
600           std::make_pair(AVRC_PDU_INFORM_DISPLAY_CHARSET, "AVRC_PDU_INFORM_DISPLAY_CHARSET"),
601           std::make_pair(AVRC_PDU_INFORM_BATTERY_STAT_OF_CT, "AVRC_PDU_INFORM_BATTERY_STAT_OF_CT"),
602           std::make_pair(AVRC_PDU_GET_ELEMENT_ATTR, "AVRC_PDU_GET_ELEMENT_ATTR"),
603           std::make_pair(AVRC_PDU_GET_PLAY_STATUS, "AVRC_PDU_GET_PLAY_STATUS"),
604           std::make_pair(AVRC_PDU_REGISTER_NOTIFICATION, "AVRC_PDU_REGISTER_NOTIFICATION"),
605           std::make_pair(AVRC_PDU_REQUEST_CONTINUATION_RSP, "AVRC_PDU_REQUEST_CONTINUATION_RSP"),
606           std::make_pair(AVRC_PDU_ABORT_CONTINUATION_RSP, "AVRC_PDU_ABORT_CONTINUATION_RSP"),
607           std::make_pair(AVRC_PDU_SET_ABSOLUTE_VOLUME, "AVRC_PDU_SET_ABSOLUTE_VOLUME"),
608           std::make_pair(AVRC_PDU_SET_ADDRESSED_PLAYER, "AVRC_PDU_SET_ADDRESSED_PLAYER"),
609           std::make_pair(AVRC_PDU_CHANGE_PATH, "AVRC_PDU_CHANGE_PATH"),
610           std::make_pair(AVRC_PDU_GET_CAPABILITIES, "AVRC_PDU_GET_CAPABILITIES"),
611           std::make_pair(AVRC_PDU_SET_BROWSED_PLAYER, "AVRC_PDU_SET_BROWSED_PLAYER"),
612           std::make_pair(AVRC_PDU_GET_FOLDER_ITEMS, "AVRC_PDU_GET_FOLDER_ITEMS"),
613           std::make_pair(AVRC_PDU_GET_ITEM_ATTRIBUTES, "AVRC_PDU_GET_ITEM_ATTRIBUTES"),
614           std::make_pair(AVRC_PDU_PLAY_ITEM, "AVRC_PDU_PLAY_ITEM"),
615           std::make_pair(AVRC_PDU_SEARCH, "AVRC_PDU_SEARCH"),
616           std::make_pair(AVRC_PDU_ADD_TO_NOW_PLAYING, "AVRC_PDU_ADD_TO_NOW_PLAYING"),
617           std::make_pair(AVRC_PDU_GET_TOTAL_NUM_OF_ITEMS, "AVRC_PDU_GET_TOTAL_NUM_OF_ITEMS"),
618           std::make_pair(AVRC_PDU_GENERAL_REJECT, "AVRC_PDU_GENERAL_REJECT"),
619   };
620   for (const auto& pdu : pdus) {
621     ASSERT_TRUE(dump_rc_pdu(pdu.first).starts_with(pdu.second));
622   }
623   ASSERT_TRUE(dump_rc_pdu(std::numeric_limits<uint8_t>::max()).starts_with("Unknown"));
624 }
625 
TEST_F(BtifCoreWithControllerTest,btif_dm_get_connection_state__unconnected)626 TEST_F(BtifCoreWithControllerTest, btif_dm_get_connection_state__unconnected) {
627   ASSERT_EQ(0, btif_dm_get_connection_state(kRawAddress));
628 }
629 
TEST_F(BtifCoreWithConnectionTest,btif_dm_get_connection_state__connected_no_encryption)630 TEST_F(BtifCoreWithConnectionTest, btif_dm_get_connection_state__connected_no_encryption) {
631   test::mock::stack_btm_sec::BTM_IsEncrypted.body = [](const RawAddress& /* bd_addr */,
632                                                        tBT_TRANSPORT transport) {
633     switch (transport) {
634       case BT_TRANSPORT_AUTO:
635         return false;
636       case BT_TRANSPORT_BR_EDR:
637         return false;
638       case BT_TRANSPORT_LE:
639         return false;
640     }
641     return false;
642   };
643   ASSERT_EQ(1, btif_dm_get_connection_state(kRawAddress));
644   test::mock::stack_btm_sec::BTM_IsEncrypted = {};
645 }
646 
TEST_F(BtifCoreWithConnectionTest,btif_dm_get_connection_state__connected_classic_encryption)647 TEST_F(BtifCoreWithConnectionTest, btif_dm_get_connection_state__connected_classic_encryption) {
648   test::mock::stack_btm_sec::BTM_IsEncrypted.body = [](const RawAddress& /* bd_addr */,
649                                                        tBT_TRANSPORT transport) {
650     switch (transport) {
651       case BT_TRANSPORT_AUTO:
652         return false;
653       case BT_TRANSPORT_BR_EDR:
654         return true;
655       case BT_TRANSPORT_LE:
656         return false;
657     }
658     return false;
659   };
660   ASSERT_EQ(3, btif_dm_get_connection_state(kRawAddress));
661 
662   test::mock::stack_btm_sec::BTM_IsEncrypted = {};
663 }
664 
TEST_F(BtifCoreWithConnectionTest,btif_dm_get_connection_state__connected_le_encryption)665 TEST_F(BtifCoreWithConnectionTest, btif_dm_get_connection_state__connected_le_encryption) {
666   test::mock::stack_btm_sec::BTM_IsEncrypted.body = [](const RawAddress& /* bd_addr */,
667                                                        tBT_TRANSPORT transport) {
668     switch (transport) {
669       case BT_TRANSPORT_AUTO:
670         return false;
671       case BT_TRANSPORT_BR_EDR:
672         return false;
673       case BT_TRANSPORT_LE:
674         return true;
675     }
676     return false;
677   };
678   ASSERT_EQ(5, btif_dm_get_connection_state(kRawAddress));
679   test::mock::stack_btm_sec::BTM_IsEncrypted = {};
680 }
681 
TEST_F(BtifCoreWithConnectionTest,btif_dm_get_connection_state__connected_both_encryption)682 TEST_F(BtifCoreWithConnectionTest, btif_dm_get_connection_state__connected_both_encryption) {
683   test::mock::stack_btm_sec::BTM_IsEncrypted.body = [](const RawAddress& /* bd_addr */,
684                                                        tBT_TRANSPORT transport) {
685     switch (transport) {
686       case BT_TRANSPORT_AUTO:
687         return false;
688       case BT_TRANSPORT_BR_EDR:
689         return true;
690       case BT_TRANSPORT_LE:
691         return true;
692     }
693     return false;
694   };
695   ASSERT_EQ(7, btif_dm_get_connection_state(kRawAddress));
696   test::mock::stack_btm_sec::BTM_IsEncrypted = {};
697 }
698 
TEST_F(BtifCoreWithConnectionTest,btif_dm_get_connection_state_sync)699 TEST_F(BtifCoreWithConnectionTest, btif_dm_get_connection_state_sync) {
700   test::mock::stack_btm_sec::BTM_IsEncrypted.body = [](const RawAddress& /* bd_addr */,
701                                                        tBT_TRANSPORT transport) {
702     switch (transport) {
703       case BT_TRANSPORT_AUTO:
704         return false;
705       case BT_TRANSPORT_BR_EDR:
706         return true;
707       case BT_TRANSPORT_LE:
708         return true;
709     }
710     return false;
711   };
712   ASSERT_EQ(7, btif_dm_get_connection_state_sync(kRawAddress));
713 
714   test::mock::stack_btm_sec::BTM_IsEncrypted = {};
715 }
716 
__anon9af3e0a70d02(const char* key, char* value, const char* ) 717 auto get_properties = [](const char* key, char* value, const char* /* default_value */) -> size_t {
718   static bluetooth::bqr::BqrConfiguration config{
719           .report_action = bluetooth::bqr::REPORT_ACTION_ADD,
720           .quality_event_mask = 0x1ffff,  // Everything
721           .minimum_report_interval_ms = 1000,
722           .vnd_quality_mask = 29,
723           .vnd_trace_mask = 5,
724           .report_interval_multiple = 2,
725   };
726   if (std::string(key) == bluetooth::bqr::kpPropertyEventMask) {
727     std::string event_mask = std::to_string(config.quality_event_mask);
728     std::copy(event_mask.cbegin(), event_mask.cend(), value);
729     return event_mask.size();
730   }
731   if (std::string(key) == bluetooth::bqr::kpPropertyMinReportIntervalMs) {
732     std::string interval = std::to_string(config.minimum_report_interval_ms);
733     std::copy(interval.cbegin(), interval.cend(), value);
734     return interval.size();
735   }
736   return 0;
737 };
738 
TEST_F(BtifCoreWithControllerTest,debug_dump_unconfigured)739 TEST_F(BtifCoreWithControllerTest, debug_dump_unconfigured) {
740   int fds[2];
741   ASSERT_EQ(0, socketpair(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK, 0, fds));
742   static int write_fd = fds[0];
743   static int read_fd = fds[1];
744   auto reading_promise = std::make_unique<std::promise<void>>();
745   auto reading_done = reading_promise->get_future();
746 
747   do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
748   do_in_main_thread(BindOnce(
749           [](std::unique_ptr<std::promise<void>> done_promise) {
750             char line_buf[1024] = "";
751             int bytes_read = read(read_fd, line_buf, 1024);
752             EXPECT_GT(bytes_read, 0);
753             EXPECT_NE(std::string(line_buf).find("Event queue is empty"), std::string::npos);
754             done_promise->set_value();
755           },
756           std::move(reading_promise)));
757   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
758   close(write_fd);
759   close(read_fd);
760 }
761 
762 class BtifCoreWithVendorSupportTest : public BtifCoreWithControllerTest {
763 protected:
SetUp()764   void SetUp() override {
765     BtifCoreWithControllerTest::SetUp();
766     bluetooth::hci::testing::mock_hci_layer_ = &hci_;
767     test::mock::osi_properties::osi_property_get.body = get_properties;
768 
769     std::promise<void> configuration_promise;
770     auto configuration_done = configuration_promise.get_future();
771     EXPECT_CALL(hci_,
772                 EnqueueCommand(_, Matcher<ContextualOnceCallback<void(CommandCompleteView)>>(_)))
773             .WillOnce(
774                     // Replace with real PDL for 0xfc17
775                     [&configuration_promise](
776                             std::unique_ptr<CommandBuilder> cmd,
777                             ContextualOnceCallback<void(CommandCompleteView)> callback) {
778                       auto cmd_view = VendorCommandView::Create(
779                               CommandView::Create(BuilderToView(std::move(cmd))));
780                       EXPECT_TRUE(cmd_view.IsValid());
781                       auto response = CommandCompleteView::Create(
782                               EventView::Create(BuilderToView(CommandCompleteBuilder::Create(
783                                       1, cmd_view.GetOpCode(), std::make_unique<RawBuilder>()))));
784                       EXPECT_TRUE(response.IsValid());
785                       callback(response);
786                       configuration_promise.set_value();
787                     })
788             .RetiresOnSaturation();
789     EXPECT_CALL(hci_,
790                 EnqueueCommand(_, Matcher<ContextualOnceCallback<void(CommandCompleteView)>>(_)))
791             .WillOnce([](std::unique_ptr<CommandBuilder> cmd,
792                          ContextualOnceCallback<void(CommandCompleteView)> callback) {
793               auto cmd_view = ControllerBqrView::Create(VendorCommandView::Create(
794                       CommandView::Create(BuilderToView(std::move(cmd)))));
795               EXPECT_TRUE(cmd_view.IsValid());
796               auto response = ControllerBqrCompleteView::Create(CommandCompleteView::Create(
797                       EventView::Create(BuilderToView(ControllerBqrCompleteBuilder::Create(
798                               1, ErrorCode::SUCCESS, cmd_view.GetBqrQualityEventMask())))));
799               EXPECT_TRUE(response.IsValid());
800               callback(response);
801             })
802             .RetiresOnSaturation();
803     EXPECT_CALL(hci_, RegisterVendorSpecificEventHandler(VseSubeventCode::BQR_EVENT, _))
804             .WillOnce(SaveArg<1>(&this->vse_callback_));
805     do_in_main_thread(BindOnce([]() { bluetooth::bqr::EnableBtQualityReport(get_main()); }));
806     ASSERT_EQ(std::future_status::ready, configuration_done.wait_for(std::chrono::seconds(1)));
807   }
808 
TearDown()809   void TearDown() override {
810     std::promise<void> disable_promise;
811     auto disable_future = disable_promise.get_future();
812     auto set_promise = [&disable_promise]() { disable_promise.set_value(); };
813     EXPECT_CALL(hci_, UnregisterVendorSpecificEventHandler(VseSubeventCode::BQR_EVENT));
814     EXPECT_CALL(hci_,
815                 EnqueueCommand(_, Matcher<ContextualOnceCallback<void(CommandCompleteView)>>(_)))
816             .WillOnce(Invoke(set_promise))
817             .RetiresOnSaturation();
818     do_in_main_thread(BindOnce([]() { bluetooth::bqr::DisableBtQualityReport(); }));
819     ASSERT_EQ(std::future_status::ready, disable_future.wait_for(std::chrono::seconds(1)));
820 
821     bluetooth::hci::testing::mock_hci_layer_ = nullptr;
822     BtifCoreWithControllerTest::TearDown();
823   }
824   bluetooth::hci::testing::MockHciLayer hci_;
825   ContextualCallback<void(VendorSpecificEventView)> vse_callback_;
826 };
827 
TEST_F(BtifCoreWithVendorSupportTest,configure_bqr_test)828 TEST_F(BtifCoreWithVendorSupportTest, configure_bqr_test) {}
829 
TEST_F(BtifCoreWithVendorSupportTest,send_a2dp_audio_choppy)830 TEST_F(BtifCoreWithVendorSupportTest, send_a2dp_audio_choppy) {
831   std::promise<void> a2dp_event_promise;
832   auto event_reported = a2dp_event_promise.get_future();
833   callback_map_["link_quality_report_callback"] = [&a2dp_event_promise]() {
834     a2dp_event_promise.set_value();
835   };
836   auto view = VendorSpecificEventView::Create(
837           EventView::Create(BuilderToView(BqrLinkQualityEventBuilder::Create(
838                   QualityReportId::A2DP_AUDIO_CHOPPY, BqrPacketType::TYPE_3DH3, 0x123,
839                   Role::CENTRAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
840                   std::make_unique<RawBuilder>()))));
841   EXPECT_TRUE(view.IsValid());
842   vse_callback_(view);
843   ASSERT_EQ(std::future_status::ready, event_reported.wait_for(std::chrono::seconds(1)));
844 }
845 
TEST_F(BtifCoreWithVendorSupportTest,send_lmp_ll_trace)846 TEST_F(BtifCoreWithVendorSupportTest, send_lmp_ll_trace) {
847   auto payload = std::make_unique<RawBuilder>();
848   payload->AddOctets({'d', 'a', 't', 'a'});
849   auto view = VendorSpecificEventView::Create(EventView::Create(
850           BuilderToView(BqrLmpLlMessageTraceEventBuilder::Create(0x123, std::move(payload)))));
851   EXPECT_TRUE(view.IsValid());
852   vse_callback_(view);
853 }
854 
855 class BtifCoreVseWithSocketTest : public BtifCoreWithVendorSupportTest {
856 protected:
SetUp()857   void SetUp() override {
858     BtifCoreWithVendorSupportTest::SetUp();
859     int fds[2];
860     ASSERT_EQ(0, socketpair(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK, 0, fds));
861     write_fd_ = fds[0];
862     read_fd_ = fds[1];
863   }
TearDown()864   void TearDown() override {
865     BtifCoreWithVendorSupportTest::TearDown();
866     close(write_fd_);
867     close(read_fd_);
868   }
869   int write_fd_;
870   int read_fd_;
871 };
872 
TEST_F(BtifCoreVseWithSocketTest,debug_dump_empty)873 TEST_F(BtifCoreVseWithSocketTest, debug_dump_empty) {
874   static int write_fd = write_fd_;
875   static int read_fd = read_fd_;
876   auto reading_promise = std::make_unique<std::promise<void>>();
877   auto reading_done = reading_promise->get_future();
878 
879   do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
880   do_in_main_thread(BindOnce(
881           [](std::unique_ptr<std::promise<void>> done_promise) {
882             char line_buf[1024] = "";
883             int bytes_read = read(read_fd, line_buf, 1024);
884             EXPECT_GT(bytes_read, 0);
885             EXPECT_NE(std::string(line_buf).find("Event queue is empty"), std::string::npos);
886             done_promise->set_value();
887           },
888           std::move(reading_promise)));
889   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
890 }
891 
TEST_F(BtifCoreVseWithSocketTest,send_lmp_ll_msg)892 TEST_F(BtifCoreVseWithSocketTest, send_lmp_ll_msg) {
893   auto payload = std::make_unique<RawBuilder>();
894   payload->AddOctets({'d', 'a', 't', 'a'});
895   auto view = VendorSpecificEventView::Create(EventView::Create(
896           BuilderToView(BqrLmpLlMessageTraceEventBuilder::Create(0x123, std::move(payload)))));
897   EXPECT_TRUE(view.IsValid());
898 
899   static int read_fd = read_fd_;
900   auto reading_promise = std::make_unique<std::promise<void>>();
901   auto reading_done = reading_promise->get_future();
902 
903   static int write_fd = write_fd_;
904   do_in_main_thread(BindOnce([]() { bluetooth::bqr::SetLmpLlMessageTraceLogFd(write_fd); }));
905   vse_callback_(view);
906 
907   do_in_main_thread(BindOnce(
908           [](std::unique_ptr<std::promise<void>> done_promise) {
909             char line_buf[1024] = "";
910             std::string line;
911             int bytes_read = read(read_fd, line_buf, 1024);
912             EXPECT_GT(bytes_read, 0);
913             line = std::string(line_buf);
914             EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
915             EXPECT_NE(line.find("data"), std::string::npos);
916             done_promise->set_value();
917           },
918           std::move(reading_promise)));
919   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
920 }
921 
TEST_F(BtifCoreVseWithSocketTest,debug_dump_a2dp_choppy_no_payload)922 TEST_F(BtifCoreVseWithSocketTest, debug_dump_a2dp_choppy_no_payload) {
923   auto payload = std::make_unique<RawBuilder>();
924   auto view = VendorSpecificEventView::Create(
925           EventView::Create(BuilderToView(BqrA2dpAudioChoppyEventBuilder::Create(
926                   BqrPacketType::TYPE_3DH3, 0x123, Role::CENTRAL, 1, 2 /* rssi */, 3, 4,
927                   5 /* afh_select_uni */, 6 /* lsto */, 7, 8, 9, 10, 11 /* last_tx_ack_timestamp */,
928                   12, 13, 14, 15 /* buffer_underflow_bytes */, std::move(payload)))));
929   EXPECT_TRUE(view.IsValid());
930   vse_callback_(view);
931 
932   static int write_fd = write_fd_;
933   static int read_fd = read_fd_;
934   auto reading_promise = std::make_unique<std::promise<void>>();
935   auto reading_done = reading_promise->get_future();
936 
937   do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
938   do_in_main_thread(BindOnce(
939           [](std::unique_ptr<std::promise<void>> done_promise) {
940             char line_buf[1024] = "";
941             std::string line;
942             int bytes_read = read(read_fd, line_buf, 1024);
943             EXPECT_GT(bytes_read, 0);
944             line = std::string(line_buf);
945             EXPECT_EQ(line.find("Event queue is empty"), std::string::npos);
946             EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
947             EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
948             EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
949             done_promise->set_value();
950           },
951           std::move(reading_promise)));
952   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
953 }
954 
TEST_F(BtifCoreVseWithSocketTest,debug_dump_a2dp_choppy)955 TEST_F(BtifCoreVseWithSocketTest, debug_dump_a2dp_choppy) {
956   auto payload = std::make_unique<RawBuilder>();
957   payload->AddOctets({'d', 'a', 't', 'a'});
958   auto view = VendorSpecificEventView::Create(
959           EventView::Create(BuilderToView(BqrA2dpAudioChoppyEventBuilder::Create(
960                   BqrPacketType::TYPE_3DH3, 0x123, Role::CENTRAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
961                   12, 13, 14, 15, std::move(payload)))));
962   EXPECT_TRUE(view.IsValid());
963   vse_callback_(view);
964 
965   static int write_fd = write_fd_;
966   static int read_fd = read_fd_;
967   auto reading_promise = std::make_unique<std::promise<void>>();
968   auto reading_done = reading_promise->get_future();
969 
970   do_in_main_thread(BindOnce([]() { bluetooth::bqr::DebugDump(write_fd); }));
971   do_in_main_thread(BindOnce(
972           [](std::unique_ptr<std::promise<void>> done_promise) {
973             char line_buf[1024] = "";
974             std::string line;
975             int bytes_read = read(read_fd, line_buf, 1024);
976             EXPECT_GT(bytes_read, 0);
977             line = std::string(line_buf);
978             EXPECT_EQ(line.find("Event queue is empty"), std::string::npos);
979             EXPECT_NE(line.find("Handle: 0x0123"), std::string::npos);
980             EXPECT_NE(line.find("UndFlow: 15"), std::string::npos);
981             EXPECT_NE(line.find("A2DP Choppy"), std::string::npos);
982             done_promise->set_value();
983           },
984           std::move(reading_promise)));
985   EXPECT_EQ(std::future_status::ready, reading_done.wait_for(std::chrono::seconds(1)));
986 }
987 
988 class BtifCoreSocketTest : public BtifCoreWithControllerTest {
989 protected:
SetUp()990   void SetUp() override {
991     BtifCoreWithControllerTest::SetUp();
992     fake_osi_ = std::make_unique<test::fake::FakeOsi>();
993     uid_set = uid_set_create();
994     thread_t* kThreadPtr = reinterpret_cast<thread_t*>(0xbadbadbad);
995     test::mock::osi_thread::thread_new.body = [kThreadPtr](const char* name) -> thread_t* {
996       bluetooth::log::info("Explicitly not starting thread {}", name);
997       return kThreadPtr;
998     };
999     test::mock::osi_thread::thread_free.body = [kThreadPtr](thread_t* ptr_to_free) {
1000       ASSERT_EQ(ptr_to_free, kThreadPtr);
1001     };
1002     btif_sock_init(uid_set);
1003   }
1004 
TearDown()1005   void TearDown() override {
1006     test::mock::osi_thread::thread_new = {};
1007     test::mock::osi_thread::thread_free = {};
1008     btif_sock_cleanup();
1009     uid_set_destroy(uid_set);
1010     BtifCoreWithControllerTest::TearDown();
1011   }
1012 
1013   std::unique_ptr<test::fake::FakeOsi> fake_osi_;
1014   uid_set_t* uid_set;
1015 };
1016 
TEST_F(BtifCoreSocketTest,empty_test)1017 TEST_F(BtifCoreSocketTest, empty_test) {}
1018 
TEST_F(BtifCoreSocketTest,CreateRfcommServerSocket)1019 TEST_F(BtifCoreSocketTest, CreateRfcommServerSocket) {
1020   static constexpr int kChannelOne = 1;
1021   static constexpr int kFlags = 2;
1022   static constexpr int kAppUid = 3;
1023   const Uuid server_uuid = Uuid::From16Bit(UUID_SERVCLASS_SERIAL_PORT);
1024   int socket_number = 0;
1025   btsock_data_path_t data_path = BTSOCK_DATA_PATH_NO_OFFLOAD;
1026   uint64_t hub_id = 0;
1027   uint64_t endpoint_id = 0;
1028   int max_rx_packet_size = 0;
1029   ASSERT_EQ(BT_STATUS_SUCCESS,
1030             btif_sock_get_interface()->listen(
1031                     BTSOCK_RFCOMM, "TestService", &server_uuid, kChannelOne, &socket_number, kFlags,
1032                     kAppUid, data_path, "TestSocket", hub_id, endpoint_id, max_rx_packet_size));
1033 }
1034 
TEST_F(BtifCoreSocketTest,CreateTwoRfcommServerSockets)1035 TEST_F(BtifCoreSocketTest, CreateTwoRfcommServerSockets) {
1036   static constexpr int kChannelOne = 1;
1037   static constexpr int kFlags = 2;
1038   static constexpr int kAppUid = 3;
1039   const Uuid server_uuid = Uuid::From16Bit(UUID_SERVCLASS_SERIAL_PORT);
1040   int socket_number = 0;
1041   btsock_data_path_t data_path = BTSOCK_DATA_PATH_NO_OFFLOAD;
1042   uint64_t hub_id = 0;
1043   uint64_t endpoint_id = 0;
1044   int max_rx_packet_size = 0;
1045   ASSERT_EQ(BT_STATUS_SUCCESS,
1046             btif_sock_get_interface()->listen(
1047                     BTSOCK_RFCOMM, "TestService", &server_uuid, kChannelOne, &socket_number, kFlags,
1048                     kAppUid, data_path, "TestSocket", hub_id, endpoint_id, max_rx_packet_size));
1049   static constexpr int kChannelTwo = 2;
1050   static constexpr int kFlagsTwo = 4;
1051   static constexpr int kAppUidTwo = 6;
1052   const Uuid server_uuid_two = Uuid::FromString("12345678-1234-2345-3456-456789123456");
1053   int socket_number_two = 1;
1054   ASSERT_EQ(BT_STATUS_SUCCESS, btif_sock_get_interface()->listen(
1055                                        BTSOCK_RFCOMM, "ServiceTwo", &server_uuid_two, kChannelTwo,
1056                                        &socket_number_two, kFlagsTwo, kAppUidTwo, data_path,
1057                                        "TestSocket", hub_id, endpoint_id, max_rx_packet_size));
1058 }
1059 
TEST_F(BtifCoreSocketTest,CreateManyRfcommServerSockets)1060 TEST_F(BtifCoreSocketTest, CreateManyRfcommServerSockets) {
1061   char server_uuid_str[] = "____5678-1234-2345-3456-456789123456";
1062   int number_of_sockets = 20;
1063   for (int i = 0; i < number_of_sockets; i++) {
1064     int channel = 11;
1065     int flags = 0;
1066     int app_uuid = i + 3;
1067     int socket_number = 0;
1068     server_uuid_str[3] = i % 10 + '0';
1069     server_uuid_str[2] = (i / 10) % 10 + '0';
1070     server_uuid_str[1] = (i / 100) % 10 + '0';
1071     server_uuid_str[0] = (i / 1000) % 10 + '0';
1072     Uuid server_uuid = Uuid::FromString(server_uuid_str);
1073     btsock_data_path_t data_path = BTSOCK_DATA_PATH_NO_OFFLOAD;
1074     uint64_t hub_id = 0;
1075     uint64_t endpoint_id = 0;
1076     int max_rx_packet_size = 0;
1077     ASSERT_EQ(BT_STATUS_SUCCESS,
1078               btif_sock_get_interface()->listen(
1079                       BTSOCK_RFCOMM, "TestService", &server_uuid, channel, &socket_number, flags,
1080                       app_uuid, data_path, "TestSocket", hub_id, endpoint_id, max_rx_packet_size));
1081     ASSERT_EQ(0, close(socket_number));
1082   }
1083 }
1084