1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright 2021 The Android Open Source Project
*
* 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 <gtest/gtest.h>
#include <future>
#include <map>
#include "bta/include/bta_ag_api.h"
#include "btcore/include/module.h"
#include "btif/include/btif_api.h"
#include "btif/include/btif_common.h"
#include "types/raw_address.h"
void set_hal_cbacks(bt_callbacks_t* callbacks);
uint8_t appl_trace_level = BT_TRACE_LEVEL_DEBUG;
uint8_t btif_trace_level = BT_TRACE_LEVEL_DEBUG;
uint8_t btu_trace_level = BT_TRACE_LEVEL_DEBUG;
const tBTA_AG_RES_DATA tBTA_AG_RES_DATA::kEmpty = {};
module_t bt_utils_module;
module_t gd_controller_module;
module_t gd_idle_module;
module_t gd_shim_module;
module_t osi_module;
namespace {
auto timeout_time = std::chrono::seconds(3);
std::map<std::string, std::function<void()>> callback_map_;
#define TESTCB \
if (callback_map_.find(__func__) != callback_map_.end()) \
callback_map_[__func__]();
void adapter_state_changed_callback(bt_state_t state) {}
void adapter_properties_callback(bt_status_t status, int num_properties,
bt_property_t* properties) {}
void remote_device_properties_callback(bt_status_t status, RawAddress* bd_addr,
int num_properties,
bt_property_t* properties) {}
void device_found_callback(int num_properties, bt_property_t* properties) {}
void discovery_state_changed_callback(bt_discovery_state_t state) {}
void pin_request_callback(RawAddress* remote_bd_addr, bt_bdname_t* bd_name,
uint32_t cod, bool min_16_digit) {}
void ssp_request_callback(RawAddress* remote_bd_addr, bt_bdname_t* bd_name,
uint32_t cod, bt_ssp_variant_t pairing_variant,
uint32_t pass_key) {}
void bond_state_changed_callback(bt_status_t status, RawAddress* remote_bd_addr,
bt_bond_state_t state, int fail_reason) {}
void address_consolidate_callback(RawAddress* main_bd_addr,
RawAddress* secondary_bd_addr) {}
void acl_state_changed_callback(bt_status_t status, RawAddress* remote_bd_addr,
bt_acl_state_t state, int transport_link_type,
bt_hci_error_code_t hci_reason) {}
void link_quality_report_callback(uint64_t timestamp, int report_id, int rssi,
int snr, int retransmission_count,
int packets_not_receive_count,
int negative_acknowledgement_count) {}
void callback_thread_event(bt_cb_thread_evt evt) { TESTCB; }
void dut_mode_recv_callback(uint16_t opcode, uint8_t* buf, uint8_t len) {}
void le_test_mode_callback(bt_status_t status, uint16_t num_packets) {}
void energy_info_callback(bt_activity_energy_info* energy_info,
bt_uid_traffic_t* uid_data) {}
void generate_local_oob_data_callback(tBT_TRANSPORT transport,
bt_oob_data_t oob_data) {}
void switch_buffer_size_callback(bool is_low_latency_buffer_size) {}
void switch_codec_callback(bool is_low_latency_buffer_size) {}
#undef TESTCB
bt_callbacks_t callbacks = {
.size = sizeof(bt_callbacks_t),
.adapter_state_changed_cb = adapter_state_changed_callback,
.adapter_properties_cb = adapter_properties_callback,
.remote_device_properties_cb = remote_device_properties_callback,
.device_found_cb = device_found_callback,
.discovery_state_changed_cb = discovery_state_changed_callback,
.pin_request_cb = pin_request_callback,
.ssp_request_cb = ssp_request_callback,
.bond_state_changed_cb = bond_state_changed_callback,
.address_consolidate_cb = address_consolidate_callback,
.acl_state_changed_cb = acl_state_changed_callback,
.thread_evt_cb = callback_thread_event,
.dut_mode_recv_cb = dut_mode_recv_callback,
.le_test_mode_cb = le_test_mode_callback,
.energy_info_cb = energy_info_callback,
.link_quality_report_cb = link_quality_report_callback,
.generate_local_oob_data_cb = generate_local_oob_data_callback,
.switch_buffer_size_cb = switch_buffer_size_callback,
.switch_codec_cb = switch_codec_callback,
};
} // namespace
class BtifCoreTest : public ::testing::Test {
protected:
void SetUp() override {
callback_map_.clear();
set_hal_cbacks(&callbacks);
auto promise = std::promise<void>();
auto future = promise.get_future();
callback_map_["callback_thread_event"] = [&promise]() {
promise.set_value();
};
btif_init_bluetooth();
ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
callback_map_.erase("callback_thread_event");
}
void TearDown() override {
auto promise = std::promise<void>();
auto future = promise.get_future();
callback_map_["callback_thread_event"] = [&promise]() {
promise.set_value();
};
btif_cleanup_bluetooth();
ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
callback_map_.erase("callback_thread_event");
}
};
std::promise<int> promise0;
void callback0(int val) { promise0.set_value(val); }
TEST_F(BtifCoreTest, test_post_on_bt_simple0) {
const int val = 123;
promise0 = std::promise<int>();
std::future<int> future0 = promise0.get_future();
post_on_bt_jni([=]() { callback0(val); });
ASSERT_EQ(std::future_status::ready, future0.wait_for(timeout_time));
ASSERT_EQ(val, future0.get());
}
TEST_F(BtifCoreTest, test_post_on_bt_jni_simple1) {
std::promise<void> promise;
std::future<void> future = promise.get_future();
post_on_bt_jni([=, &promise]() { promise.set_value(); });
ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
}
TEST_F(BtifCoreTest, test_post_on_bt_jni_simple2) {
std::promise<void> promise;
std::future<void> future = promise.get_future();
BtJniClosure closure = [&promise]() { promise.set_value(); };
post_on_bt_jni(closure);
ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
}
TEST_F(BtifCoreTest, test_post_on_bt_jni_simple3) {
const int val = 456;
std::promise<int> promise;
auto future = promise.get_future();
BtJniClosure closure = [&promise, val]() { promise.set_value(val); };
post_on_bt_jni(closure);
ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
ASSERT_EQ(val, future.get());
}
|
