1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "comm_log.h"
17 #include "softbus_adapter_bt_common.h"
18 #include "softbus_adapter_mem.h"
19 #include "softbus_error_code.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22
23 #include "assert_helper.h"
24 #include "bluetooth_mock.h"
25
26 #define STATE_LISTENER_MAX_NUM 20
27
28 using namespace testing::ext;
29 using ::testing::_;
30 using ::testing::AtLeast;
31 using ::testing::AtMost;
32 using ::testing::Return;
33
34 namespace OHOS {
35 static SoftBusBtStateListener *GetMockBtStateListener();
36
37 static StRecordCtx g_btStateChangedCtx("OnBtStateChanged");
38 static BtAddrRecordCtx g_btAclStateChangedCtx("OnBtAclStateChanged");
39
40 /**
41 * @tc.name: AdapterBtCommonTest_ConvertStatus
42 * @tc.desc: test enable bt
43 * @tc.type: FUNC
44 * @tc.require: NONE
45 */
46 HWTEST(AdapterBtCommonTest, SoftBusEnableBt, TestSize.Level3)
47 {
48 MockBluetooth mocker;
49 EXPECT_CALL(mocker, EnableBle()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
50 EXPECT_EQ(SoftBusEnableBt(), SOFTBUS_OK);
51 EXPECT_EQ(SoftBusEnableBt(), SOFTBUS_COMM_BLE_ENABLE_ERR);
52 }
53
54 /**
55 * @tc.name: AdapterBtCommonTest_SoftBusDisableBt
56 * @tc.desc: test disable bt
57 * @tc.type: FUNC
58 * @tc.require: NONE
59 */
60 HWTEST(AdapterBtCommonTest, SoftBusDisableBt, TestSize.Level3)
61 {
62 MockBluetooth mocker;
63 EXPECT_CALL(mocker, DisableBle()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
64 EXPECT_EQ(SoftBusDisableBt(), SOFTBUS_OK);
65 EXPECT_EQ(SoftBusDisableBt(), SOFTBUS_COMM_BLE_DISABLE_ERR);
66 }
67
68 /**
69 * @tc.name: AdapterBtCommonTest_SoftBusGetBtState
70 * @tc.desc: test get bt status
71 * @tc.type: FUNC
72 * @tc.require: NONE
73 */
74 HWTEST(AdapterBtCommonTest, SoftBusGetBtState, TestSize.Level3)
75 {
76 MockBluetooth mocker;
77 EXPECT_CALL(mocker, IsBleEnabled()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
78 EXPECT_EQ(SoftBusGetBtState(), BLE_ENABLE);
79 EXPECT_EQ(SoftBusGetBtState(), BLE_DISABLE);
80 }
81
82 /**
83 * @tc.name: AdapterBtCommonTest_SoftBusGetBtMacAddr
84 * @tc.desc: test get bt mac address
85 * @tc.type: FUNC
86 * @tc.require: NONE
87 */
88 HWTEST(AdapterBtCommonTest, SoftBusGetBtMacAddr, TestSize.Level3)
89 {
90 EXPECT_EQ(SoftBusGetBtMacAddr(nullptr), SOFTBUS_INVALID_PARAM);
91 MockBluetooth mocker;
92 SoftBusBtAddr mac = { 0 };
93 EXPECT_CALL(mocker, GetLocalAddr(mac.addr, BT_ADDR_LEN)).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
94 EXPECT_EQ(SoftBusGetBtMacAddr(&mac), SOFTBUS_OK);
95 EXPECT_EQ(SoftBusGetBtMacAddr(&mac), SOFTBUS_COMM_BLUETOOTH_UNDERLAY_GET_ADDR_ERR);
96 }
97
98 /**
99 * @tc.name: AdapterBtCommonTest_SoftBusSetBtName
100 * @tc.desc: test set bt name
101 * @tc.type: FUNC
102 * @tc.require: NONE
103 */
104 HWTEST(AdapterBtCommonTest, SoftBusSetBtName, TestSize.Level3)
105 {
106 MockBluetooth mocker;
107 const char *name = "awesome";
108 EXPECT_CALL(mocker, SetLocalName((unsigned char *)name, (unsigned char)strlen(name)))
109 .Times(2)
110 .WillOnce(Return(true))
111 .WillOnce(Return(false));
112 EXPECT_EQ(SoftBusSetBtName(name), SOFTBUS_OK);
113 EXPECT_EQ(SoftBusSetBtName(name), SOFTBUS_COMM_BLUETOOTH_UNDERLAY_SET_NAME_ERR);
114 }
115
PrepareBtStateListener(MockBluetooth & mocker,int32_t * outlistenerId)116 static testing::AssertionResult PrepareBtStateListener(MockBluetooth &mocker, int32_t *outlistenerId)
117 {
118 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
119 auto listenerId = -1;
120 int32_t ret = SoftBusAddBtStateListener(GetMockBtStateListener(), &listenerId);
121 if (listenerId < 0) {
122 return testing::AssertionFailure() << "SoftBusAddBtStateListener failed";
123 }
124
125 ret = SoftBusBtInit();
126 EXPECT_EQ(ret, SOFTBUS_OK);
127
128 if (MockBluetooth::btGapCallback == nullptr) {
129 return testing::AssertionFailure() << "GapRegisterCallback is not invoke";
130 }
131 *outlistenerId = listenerId;
132 return testing::AssertionSuccess();
133 }
134
135 /**
136 * @tc.name: AdapterBtCommonTest_StateChangeCallback
137 * @tc.desc: test bt state listener callback stateChangeCallback
138 * @tc.type: FUNC
139 * @tc.require: NONE
140 */
141 HWTEST(AdapterBtCommonTest, StateChangeCallback, TestSize.Level3)
142 {
143 int32_t listenerId = -1;
144 MockBluetooth mocker;
145 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
146 ASSERT_TRUE(prepareResult);
147 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_OFF);
148
149 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_ON);
150 auto btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_ON);
151 EXPECT_TRUE(btStateResult);
152 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_ON);
153 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURNING_ON);
154 EXPECT_TRUE(btStateResult);
155
156 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_ON);
157 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_ON);
158 EXPECT_TRUE(btStateResult);
159 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_ON);
160 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURN_ON);
161 EXPECT_TRUE(btStateResult);
162
163 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_OFF);
164 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_OFF);
165 EXPECT_TRUE(btStateResult);
166 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_OFF);
167 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURNING_OFF);
168 EXPECT_TRUE(btStateResult);
169
170 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_OFF);
171 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_OFF);
172 EXPECT_TRUE(btStateResult);
173 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_OFF);
174 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURN_OFF);
175 EXPECT_TRUE(btStateResult);
176
177 // invalid status
178 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, -1);
179 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_COMM_BLUETOOTH_SWITCH_STATE_ERR);
180 EXPECT_TRUE(btStateResult);
181
182 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
183 }
184
185 /**
186 * @tc.name: AdapterBtCommonTest_StateChangeCallback
187 * @tc.desc: test bt state listener callback aclStateChangedCallbak
188 * @tc.type: FUNC
189 * @tc.require: NONE
190 */
191 HWTEST(AdapterBtCommonTest, AclStateChangedCallbak, TestSize.Level3)
192 {
193 int32_t listenerId = -1;
194 MockBluetooth mocker;
195 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
196 ASSERT_TRUE(prepareResult);
197
198 MockBluetooth::btGapCallback->aclStateChangedCallbak(nullptr, (GapAclState)-1, 0);
199
200 BdAddr bdAddr = {
201 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
202 };
203 SoftBusBtAddr addr = {
204 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
205 };
206 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_CONNECTED, 0);
207 auto aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_CONNECTED);
208 EXPECT_TRUE(aclStateResult);
209
210 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_DISCONNECTED, 0);
211 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_DISCONNECTED);
212 EXPECT_TRUE(aclStateResult);
213
214 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_CONNECTED, 0);
215 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_CONNECTED);
216 EXPECT_TRUE(aclStateResult);
217
218 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_DISCONNECTED, 0);
219 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_DISCONNECTED);
220 EXPECT_TRUE(aclStateResult);
221
222 // invalid GapAclState
223 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, (GapAclState)-1, 0);
224 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_COMM_BLUETOOTH_ACL_SWITCH_STATE_ERR);
225 EXPECT_TRUE(aclStateResult);
226
227 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
228 }
229
230 /**
231 * @tc.name: AdapterBtCommonTest_BluetoothPair
232 * @tc.desc: test bt state listener callback pairRequestedCallback
233 * @tc.type: FUNC
234 * @tc.require: NONE
235 */
236 HWTEST(AdapterBtCommonTest, PairRequestedCallback, TestSize.Level3)
237 {
238 BdAddr bdAddr = {
239 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
240 };
241 MockBluetooth mocker;
242 EXPECT_CALL(mocker, PairRequestReply(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
243 .Times(2)
244 .WillOnce(Return(false))
245 .WillOnce(Return(true));
246
247 int32_t listenerId = -1;
248 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
249 ASSERT_TRUE(prepareResult);
250
251 MockBluetooth::btGapCallback->pairRequestedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID);
252 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
253 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
254 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
255 }
256
257 /**
258 * @tc.name: AdapterBtCommonTest_PairConfiremedCallback
259 * @tc.desc: test bt state listener callback pairConfiremedCallback
260 * @tc.type: FUNC
261 * @tc.require: NONE
262 */
263 HWTEST(AdapterBtCommonTest, PairConfiremedCallback, TestSize.Level3)
264 {
265 BdAddr bdAddr = {
266 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
267 };
268 MockBluetooth mocker;
269 EXPECT_CALL(mocker, SetDevicePairingConfirmation(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
270 .Times(AtLeast(2))
271 .WillOnce(Return(false))
272 .WillRepeatedly(Return(true));
273 int32_t listenerId = -1;
274 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
275 ASSERT_TRUE(prepareResult);
276
277 MockBluetooth::btGapCallback->pairConfiremedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID, 0, 0);
278 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
279 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
280 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
281 }
282
283 /**
284 * @tc.name: SoftBusAddBtStateListener
285 * @tc.desc: test SoftBusAddBtStateListener
286 * @tc.type: FUNC
287 * @tc.require: NONE
288 */
289 HWTEST(AdapterBtCommonTest, SoftBusAddBtStateListener, TestSize.Level3)
290 {
291 auto listenerId = -1;
292 int32_t ret = SoftBusAddBtStateListener(nullptr, &listenerId);
293 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
294
295 ret = SoftBusAddBtStateListener(GetMockBtStateListener(), nullptr);
296 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
297
298 for (int i = 0; i < STATE_LISTENER_MAX_NUM; ++i) {
299 ret = SoftBusAddBtStateListener(GetMockBtStateListener(), &listenerId);
300 EXPECT_TRUE(ret == SOFTBUS_OK);
301 }
302 ret = SoftBusAddBtStateListener(GetMockBtStateListener(), &listenerId);
303 EXPECT_EQ(ret, SOFTBUS_COMM_BLUETOOTH_ADD_STATE_LISTENER_ERR);
304 }
305
StubOnBtStateChanged(int32_t listenerId,int32_t state)306 static void StubOnBtStateChanged(int32_t listenerId, int32_t state)
307 {
308 g_btStateChangedCtx.Update(listenerId, state);
309 }
310
StubOnBtAclStateChanged(int32_t listenerId,const SoftBusBtAddr * addr,int32_t aclState,int32_t hciReason)311 static void StubOnBtAclStateChanged(int32_t listenerId, const SoftBusBtAddr *addr, int32_t aclState, int32_t hciReason)
312 {
313 g_btAclStateChangedCtx.Update(listenerId, addr, aclState);
314 }
315
GetMockBtStateListener()316 static SoftBusBtStateListener *GetMockBtStateListener()
317 {
318 static SoftBusBtStateListener listener = {
319 .OnBtStateChanged = StubOnBtStateChanged,
320 .OnBtAclStateChanged = StubOnBtAclStateChanged,
321 };
322 return &listener;
323 }
324
325 } // namespace OHOS
326