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_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_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_ERR);
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_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_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 == SOFTBUS_ERR) {
119 return testing::AssertionFailure() << "SoftBusAddBtStateListener failed";
120 }
121 if (MockBluetooth::btGapCallback == nullptr) {
122 return testing::AssertionFailure() << "GapRegisterCallback is not invoke";
123 }
124 *outlistenerId = listenerId;
125 return testing::AssertionSuccess();
126 }
127
128 /**
129 * @tc.name: AdapterBtCommonTest_StateChangeCallback
130 * @tc.desc: test bt state listener callback stateChangeCallback
131 * @tc.type: FUNC
132 * @tc.require: NONE
133 */
134 HWTEST(AdapterBtCommonTest, StateChangeCallback, TestSize.Level3)
135 {
136 int listenerId = -1;
137 MockBluetooth mocker;
138 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
139 ASSERT_TRUE(prepareResult);
140
141 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_ON);
142 auto btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_ON);
143 EXPECT_TRUE(btStateResult);
144 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_ON);
145 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BT_STATE_TURNING_ON);
146 EXPECT_TRUE(btStateResult);
147
148 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_ON);
149 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_ON);
150 EXPECT_TRUE(btStateResult);
151 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_ON);
152 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BT_STATE_TURN_ON);
153 EXPECT_TRUE(btStateResult);
154
155 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURNING_OFF);
156 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURNING_OFF);
157 EXPECT_TRUE(btStateResult);
158 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURNING_OFF);
159 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BT_STATE_TURNING_OFF);
160 EXPECT_TRUE(btStateResult);
161
162 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, OHOS_GAP_STATE_TURN_OFF);
163 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BR_STATE_TURN_OFF);
164 EXPECT_TRUE(btStateResult);
165 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_LE, OHOS_GAP_STATE_TURN_OFF);
166 btStateResult = g_btStateChangedCtx.Expect(listenerId, SOFTBUS_BT_STATE_TURN_OFF);
167 EXPECT_TRUE(btStateResult);
168
169 // invalid status
170 MockBluetooth::btGapCallback->stateChangeCallback(OHOS_BT_TRANSPORT_BR_EDR, -1);
171 btStateResult = g_btStateChangedCtx.Expect(listenerId, -1);
172 EXPECT_TRUE(btStateResult);
173
174 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
175 }
176
177 /**
178 * @tc.name: AdapterBtCommonTest_StateChangeCallback
179 * @tc.desc: test bt state listener callback aclStateChangedCallbak
180 * @tc.type: FUNC
181 * @tc.require: NONE
182 */
183 HWTEST(AdapterBtCommonTest, AclStateChangedCallbak, TestSize.Level3)
184 {
185 int listenerId = -1;
186 MockBluetooth mocker;
187 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
188 ASSERT_TRUE(prepareResult);
189
190 MockBluetooth::btGapCallback->aclStateChangedCallbak(nullptr, (GapAclState)-1, 0);
191
192 BdAddr bdAddr = {
193 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
194 };
195 SoftBusBtAddr addr = {
196 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
197 };
198 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_CONNECTED, 0);
199 auto aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_CONNECTED);
200 EXPECT_TRUE(aclStateResult);
201
202 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_DISCONNECTED, 0);
203 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_DISCONNECTED);
204 EXPECT_TRUE(aclStateResult);
205
206 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_CONNECTED, 0);
207 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_CONNECTED);
208 EXPECT_TRUE(aclStateResult);
209
210 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, OHOS_GAP_ACL_STATE_LE_DISCONNECTED, 0);
211 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, SOFTBUS_ACL_STATE_LE_DISCONNECTED);
212 EXPECT_TRUE(aclStateResult);
213
214 // invalid GapAclState
215 MockBluetooth::btGapCallback->aclStateChangedCallbak(&bdAddr, (GapAclState)-1, 0);
216 aclStateResult = g_btAclStateChangedCtx.Expect(listenerId, &addr, -1);
217 EXPECT_TRUE(aclStateResult);
218
219 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
220 }
221
222 /**
223 * @tc.name: AdapterBtCommonTest_BluetoothPair
224 * @tc.desc: test bt state listener callback pairRequestedCallback
225 * @tc.type: FUNC
226 * @tc.require: NONE
227 */
228 HWTEST(AdapterBtCommonTest, PairRequestedCallback, TestSize.Level3)
229 {
230 BdAddr bdAddr = {
231 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
232 };
233 MockBluetooth mocker;
234 EXPECT_CALL(mocker, PairRequestReply(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
235 .Times(2)
236 .WillOnce(Return(false))
237 .WillOnce(Return(true));
238
239 int listenerId = -1;
240 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
241 ASSERT_TRUE(prepareResult);
242
243 MockBluetooth::btGapCallback->pairRequestedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID);
244 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
245 MockBluetooth::btGapCallback->pairRequestedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE);
246 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
247 }
248
249 /**
250 * @tc.name: AdapterBtCommonTest_PairConfiremedCallback
251 * @tc.desc: test bt state listener callback pairConfiremedCallback
252 * @tc.type: FUNC
253 * @tc.require: NONE
254 */
255 HWTEST(AdapterBtCommonTest, PairConfiremedCallback, TestSize.Level3)
256 {
257 BdAddr bdAddr = {
258 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
259 };
260 MockBluetooth mocker;
261 EXPECT_CALL(mocker, SetDevicePairingConfirmation(&bdAddr, OHOS_BT_TRANSPORT_LE, true))
262 .Times(AtLeast(2))
263 .WillOnce(Return(false))
264 .WillRepeatedly(Return(true));
265 int listenerId = -1;
266 auto prepareResult = PrepareBtStateListener(mocker, &listenerId);
267 ASSERT_TRUE(prepareResult);
268
269 MockBluetooth::btGapCallback->pairConfiremedCallback(nullptr, OHOS_BT_TRANSPORT_INVALID, 0, 0);
270 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
271 MockBluetooth::btGapCallback->pairConfiremedCallback(&bdAddr, OHOS_BT_TRANSPORT_LE, 0, 0);
272 EXPECT_EQ(SoftBusRemoveBtStateListener(listenerId), SOFTBUS_OK);
273 }
274
StubOnBtStateChanged(int32_t listenerId,int32_t state)275 static void StubOnBtStateChanged(int32_t listenerId, int32_t state)
276 {
277 g_btStateChangedCtx.Update(listenerId, state);
278 }
279
StubOnBtAclStateChanged(int32_t listenerId,const SoftBusBtAddr * addr,int32_t aclState,int32_t hciReason)280 static void StubOnBtAclStateChanged(int32_t listenerId, const SoftBusBtAddr *addr, int32_t aclState, int32_t hciReason)
281 {
282 g_btAclStateChangedCtx.Update(listenerId, addr, aclState);
283 }
284
GetMockBtStateListener()285 static SoftBusBtStateListener *GetMockBtStateListener()
286 {
287 static SoftBusBtStateListener listener = {
288 .OnBtStateChanged = StubOnBtStateChanged,
289 .OnBtAclStateChanged = StubOnBtAclStateChanged,
290 };
291 return &listener;
292 }
293
294 } // namespace OHOS
295