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 "gmock/gmock.h"
17 #include "gtest/gtest.h"
18
19 #include "softbus_adapter_bt_common.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_errcode.h"
22
23 #include "assert_helper.h"
24 #include "bluetooth_mock.h"
25
26 using namespace testing::ext;
27 using ::testing::_;
28 using ::testing::AtLeast;
29 using ::testing::AtMost;
30 using ::testing::Return;
31
32 namespace OHOS {
33 static SoftBusBtStateListener *GetMockBtStateListener();
34
35 static StRecordCtx g_btStateChangedCtx("OnBtStateChanged");
36 static BtAddrRecordCtx g_btAclStateChangedCtx("OnBtAclStateChanged");
37
38 /**
39 * @tc.name: AdapterBtCommonTest_ConvertStatus
40 * @tc.desc: test enable bt
41 * @tc.type: FUNC
42 * @tc.require: NONE
43 */
44 HWTEST(AdapterBtCommonTest, SoftBusEnableBt, TestSize.Level3)
45 {
46 MockBluetooth mocker;
47 EXPECT_CALL(mocker, EnableBle()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
48 EXPECT_EQ(SoftBusEnableBt(), SOFTBUS_OK);
49 EXPECT_EQ(SoftBusEnableBt(), SOFTBUS_COMM_BLE_ENABLE_ERR);
50 }
51
52 /**
53 * @tc.name: AdapterBtCommonTest_SoftBusDisableBt
54 * @tc.desc: test disable bt
55 * @tc.type: FUNC
56 * @tc.require: NONE
57 */
58 HWTEST(AdapterBtCommonTest, SoftBusDisableBt, TestSize.Level3)
59 {
60 MockBluetooth mocker;
61 EXPECT_CALL(mocker, DisableBle()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
62 EXPECT_EQ(SoftBusDisableBt(), SOFTBUS_OK);
63 EXPECT_EQ(SoftBusDisableBt(), SOFTBUS_COMM_BLE_DISABLE_ERR);
64 }
65
66 /**
67 * @tc.name: AdapterBtCommonTest_SoftBusGetBtState
68 * @tc.desc: test get bt status
69 * @tc.type: FUNC
70 * @tc.require: NONE
71 */
72 HWTEST(AdapterBtCommonTest, SoftBusGetBtState, TestSize.Level3)
73 {
74 MockBluetooth mocker;
75 EXPECT_CALL(mocker, IsBleEnabled()).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
76 EXPECT_EQ(SoftBusGetBtState(), BLE_ENABLE);
77 EXPECT_EQ(SoftBusGetBtState(), BLE_DISABLE);
78 }
79
80 /**
81 * @tc.name: AdapterBtCommonTest_SoftBusGetBtMacAddr
82 * @tc.desc: test get bt mac address
83 * @tc.type: FUNC
84 * @tc.require: NONE
85 */
86 HWTEST(AdapterBtCommonTest, SoftBusGetBtMacAddr, TestSize.Level3)
87 {
88 EXPECT_EQ(SoftBusGetBtMacAddr(NULL), SOFTBUS_INVALID_PARAM);
89 MockBluetooth mocker;
90 SoftBusBtAddr mac = {0};
91 EXPECT_CALL(mocker, GetLocalAddr(mac.addr, BT_ADDR_LEN)).Times(2).WillOnce(Return(true)).WillOnce(Return(false));
92 EXPECT_EQ(SoftBusGetBtMacAddr(&mac), SOFTBUS_OK);
93 EXPECT_EQ(SoftBusGetBtMacAddr(&mac), SOFTBUS_COMM_BLUETOOTH_UNDERLAY_GET_ADDR_ERR);
94 }
95
96 /**
97 * @tc.name: AdapterBtCommonTest_SoftBusSetBtName
98 * @tc.desc: test set bt name
99 * @tc.type: FUNC
100 * @tc.require: NONE
101 */
102 HWTEST(AdapterBtCommonTest, SoftBusSetBtName, TestSize.Level3)
103 {
104 MockBluetooth mocker;
105 const char *name = "awesome";
106 EXPECT_CALL(mocker, SetLocalName((unsigned char *)name, (unsigned char)strlen(name)))
107 .Times(2)
108 .WillOnce(Return(true))
109 .WillOnce(Return(false));
110 EXPECT_EQ(SoftBusSetBtName(name), SOFTBUS_OK);
111 EXPECT_EQ(SoftBusSetBtName(name), SOFTBUS_COMM_BLUETOOTH_UNDERLAY_SET_NAME_ERR);
112 }
113
PrepareBtStateListener(MockBluetooth & mocker,int * outlistenerId)114 static testing::AssertionResult PrepareBtStateListener(MockBluetooth &mocker, int *outlistenerId)
115 {
116 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
117 auto listenerId = SoftBusAddBtStateListener(GetMockBtStateListener());
118 if (listenerId < 0) {
119 return testing::AssertionFailure() << "SoftBusAddBtStateListener failed";
120 }
121
122 int32_t ret = SoftBusBtInit();
123 EXPECT_EQ(ret, SOFTBUS_OK);
124
125 if (MockBluetooth::btGapCallback == nullptr) {
126 return testing::AssertionFailure() << "GapRegisterCallback is not invoke";
127 }
128 *outlistenerId = listenerId;
129 return testing::AssertionSuccess();
130 }
131
132 /**
133 * @tc.name: AdapterBtCommonTest_StateChangeCallback
134 * @tc.desc: test bt state listener callback stateChangeCallback
135 * @tc.type: FUNC
136 * @tc.require: NONE
137 */
138 HWTEST(AdapterBtCommonTest, StateChangeCallback, TestSize.Level3)
139 {
140 int listenerId = -1;
141 MockBluetooth mocker;
142 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
143 ASSERT_TRUE(prepareResult);
144 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_OFF);
145
146 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_ON);
147 auto btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_ON);
148 EXPECT_TRUE(btStateResult);
149 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_ON);
150 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURNING_ON);
151 EXPECT_TRUE(btStateResult);
152
153 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_ON);
154 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_ON);
155 EXPECT_TRUE(btStateResult);
156 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_ON);
157 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURN_ON);
158 EXPECT_TRUE(btStateResult);
159
160 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_OFF);
161 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_OFF);
162 EXPECT_TRUE(btStateResult);
163 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_OFF);
164 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURNING_OFF);
165 EXPECT_TRUE(btStateResult);
166
167 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_OFF);
168 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_OFF);
169 EXPECT_TRUE(btStateResult);
170 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_OFF);
171 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BLE_STATE_TURN_OFF);
172 EXPECT_TRUE(btStateResult);
173
174 // invalid status
175 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, -1);
176 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_COMM_BLUETOOTH_SWITCH_STATE_ERR);
177 EXPECT_TRUE(btStateResult);
178
179 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
180 }
181
182 /**
183 * @tc.name: AdapterBtCommonTest_StateChangeCallback
184 * @tc.desc: test bt state listener callback aclStateChangedCallbak
185 * @tc.type: FUNC
186 * @tc.require: NONE
187 */
188 HWTEST(AdapterBtCommonTest, AclStateChangedCallbak, TestSize.Level3)
189 {
190 int listenerId = -1;
191 MockBluetooth mocker;
192 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
193 ASSERT_TRUE(prepareResult);
194
195 MockBluetooth::btGapCallback->aclStateChangedCallbak(nullptr, (GapAclState)-1, 0);
196
197 BdAddr bdAddr = {
198 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
199 };
200 SoftBusBtAddr addr = {
201 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
202 };
203 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_CONNECTED, 0);
204 auto aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_CONNECTED);
205 EXPECT_TRUE(aclStateResult);
206
207 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_DISCONNECTED, 0);
208 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_DISCONNECTED);
209 EXPECT_TRUE(aclStateResult);
210
211 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_CONNECTED, 0);
212 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_CONNECTED);
213 EXPECT_TRUE(aclStateResult);
214
215 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_DISCONNECTED, 0);
216 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_DISCONNECTED);
217 EXPECT_TRUE(aclStateResult);
218
219 // invalid GapAclState
220 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, (GapAclState)-1, 0);
221 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_COMM_BLUETOOTH_ACL_SWITCH_STATE_ERR);
222 EXPECT_TRUE(aclStateResult);
223
224 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
225 }
226
227 /**
228 * @tc.name: AdapterBtCommonTest_BluetoothPair
229 * @tc.desc: test bt state listener callback pairRequestedCallback
230 * @tc.type: FUNC
231 * @tc.require: NONE
232 */
233 HWTEST(AdapterBtCommonTest, PairRequestedCallback, TestSize.Level3)
234 {
235 BdAddr bdAddr = {
236 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
237 };
238 MockBluetooth mocker;
239 EXPECT_CALL(mocker, PairRequestReply(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
240 .Times(2)
241 .WillOnce(Return(false))
242 .WillOnce(Return(true));
243
244 int listenerId = -1;
245 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
246 ASSERT_TRUE(prepareResult);
247
248 MockBluetooth::btGapCallback->pairRequestedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID);
249 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
250 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
251 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
252 }
253
254 /**
255 * @tc.name: AdapterBtCommonTest_PairConfiremedCallback
256 * @tc.desc: test bt state listener callback pairConfiremedCallback
257 * @tc.type: FUNC
258 * @tc.require: NONE
259 */
260 HWTEST(AdapterBtCommonTest, PairConfiremedCallback, TestSize.Level3)
261 {
262 BdAddr bdAddr = {
263 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
264 };
265 MockBluetooth mocker;
266 EXPECT_CALL(mocker, SetDevicePairingConfirmation(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
267 .Times(AtLeast(2))
268 .WillOnce(Return(false))
269 .WillRepeatedly(Return(true));
270 int listenerId = -1;
271 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
272 ASSERT_TRUE(prepareResult);
273
274 MockBluetooth::btGapCallback->pairConfiremedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID, 0, 0);
275 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
276 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
277 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
278 }
279
StubOnBtStateChanged(int32_t listenerId,int32_t state)280 static void StubOnBtStateChanged(int32_t listenerId, int32_t state)
281 {
282 g_btStateChangedCtx.Update(listenerId, state);
283 }
284
StubOnBtAclStateChanged(int32_t listenerId,const SoftBusBtAddr * addr,int32_t aclState,int32_t hciReason)285 static void StubOnBtAclStateChanged(int32_t listenerId, const SoftBusBtAddr *addr, int32_t aclState, int32_t hciReason)
286 {
287 g_btAclStateChangedCtx.Update(listenerId, addr, aclState);
288 }
289
GetMockBtStateListener()290 static SoftBusBtStateListener *GetMockBtStateListener()
291 {
292 static SoftBusBtStateListener listener = {
293 .OnBtStateChanged = StubOnBtStateChanged,
294 .OnBtAclStateChanged = StubOnBtAclStateChanged,
295 };
296 return &listener;
297 }
298
299 } // namespace OHOS
300