1 /*
2 * Copyright (c) 2024 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 <securec.h>
17 #include <cstring>
18
19 #include "gtest/gtest.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_error_code.h"
22 #include "softbus_def.h"
23 #include "br_proxy_test_mock.h"
24 #include "br_proxy.h"
25 #include "softbus_common.h"
26 #include "nativetoken_kit.h"
27 #include "accesstoken_kit.h"
28 #include "token_setproc.h"
29 #include "softbus_conn_interface.h"
30 #include "message_handler.h"
31 #include "br_proxy.c"
32 #include "br_proxy_server_manager.c"
33
34 using namespace testing;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 #define CHANNEL_ID 5
39 #define CHANNEL_ID_ERR 0
40 #define SESSION_ID 2
41 const char *TEST_UUID = "0000FEEA-0000-1000-8000-00805F9B34FB";
42 const char *VALID_BR_MAC = "F0:FA:C7:13:56:BC";
43 const char *INVALID_BR_MAC = "F0:FA:C7:13:56:AB";
44 class BrProxyTest : public testing::Test {
45 public:
BrProxyTest()46 BrProxyTest()
47 {}
~BrProxyTest()48 ~BrProxyTest()
49 {}
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
SetUp()52 void SetUp() override
53 {}
TearDown()54 void TearDown() override
55 {}
56 };
57
AddPermission()58 static void AddPermission()
59 {
60 uint64_t tokenId;
61 const char *perms[1];
62 perms[0] = OHOS_PERMISSION_ACCESS_BLUETOOTH;
63 NativeTokenInfoParams infoInstance = {
64 .dcapsNum = 0,
65 .permsNum = 1,
66 .aclsNum = 0,
67 .dcaps = nullptr,
68 .perms = perms,
69 .acls = nullptr,
70 .processName = "BrProxyTest",
71 .aplStr = "system_basic",
72 };
73 tokenId = GetAccessTokenId(&infoInstance);
74 SetSelfTokenID(tokenId);
75 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
76 }
77
SetUpTestCase(void)78 void BrProxyTest::SetUpTestCase(void)
79 {
80 AddPermission();
81 }
82
TearDownTestCase(void)83 void BrProxyTest::TearDownTestCase(void)
84 {
85 }
86
87 BrProxyChannelInfo g_channelInfo = {
88 .peerBRMacAddr = "F0:FA:C7:13:56:BC",
89 .peerBRUuid = "0000FEEA-0000-1000-8000-00805F9B34FB",
90 .recvPri = 1,
91 .recvPriSet = true,
92 };
93
onChannelOpened(int32_t sessionId,int32_t channelId,int32_t result)94 static int32_t onChannelOpened(int32_t sessionId, int32_t channelId, int32_t result)
95 {
96 return SOFTBUS_OK;
97 }
98
onDataReceived(int32_t channelId,const char * data,uint32_t dataLen)99 static void onDataReceived(int32_t channelId, const char *data, uint32_t dataLen)
100 {
101 }
102
onChannelStatusChanged(int32_t channelId,int32_t state)103 static void onChannelStatusChanged(int32_t channelId, int32_t state)
104 {
105 }
106
107 static IBrProxyListener g_listener = {
108 .onChannelOpened = onChannelOpened,
109 .onDataReceived = onDataReceived,
110 .onChannelStatusChanged = onChannelStatusChanged,
111 };
112
113 static int32_t g_validChannelId = 1;
114 static uint32_t g_validRequestId = 1;
115 static int32_t g_invalidChannelId = 2;
116 static uint32_t g_invalidRequestId = 2;
117 static int32_t g_sessionId = 1;
118
119 HWTEST_F(BrProxyTest, BrProxyTest000, TestSize.Level1)
120 {
121 int32_t ret = TransClientInit();
122 EXPECT_EQ(SOFTBUS_OK, ret);
123 }
124
125 HWTEST_F(BrProxyTest, BrProxyTest001, TestSize.Level1)
126 {
127 int32_t ret = ClientAddChannelToList(g_sessionId, nullptr, nullptr);
128 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
129 BrProxyChannelInfo info = {
130 .peerBRMacAddr = "F0:FA:C7:13:56:BC",
131 .peerBRUuid = "0000FEEA-0000-1000-8000-00805F9B34FB",
132 };
133 ret = ClientAddChannelToList(g_sessionId, &info, nullptr);
134 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
135 ret = ClientAddChannelToList(g_sessionId, nullptr, &g_listener);
136 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
137 ret = ClientAddChannelToList(g_sessionId, &info, &g_listener);
138 EXPECT_EQ(SOFTBUS_OK, ret);
139 }
140
141 HWTEST_F(BrProxyTest, BrProxyTest002, TestSize.Level1)
142 {
143 int32_t ret = ClientUpdateList(INVALID_BR_MAC, TEST_UUID, g_validChannelId);
144 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
145 ret = ClientUpdateList(VALID_BR_MAC, TEST_UUID, g_validChannelId);
146 EXPECT_EQ(SOFTBUS_OK, ret);
147 }
148
149 HWTEST_F(BrProxyTest, BrProxyTest003, TestSize.Level1)
150 {
151 ClientBrProxyChannelInfo info;
152 int32_t ret = ClientQueryList(DEFAULT_CHANNEL_ID, nullptr, nullptr, nullptr);
153 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
154 ret = ClientQueryList(DEFAULT_CHANNEL_ID, nullptr, nullptr, &info);
155 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
156 ret = ClientQueryList(DEFAULT_CHANNEL_ID, INVALID_BR_MAC, TEST_UUID, &info);
157 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
158 ret = ClientQueryList(g_invalidChannelId, nullptr, nullptr, &info);
159 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
160 ret = ClientQueryList(DEFAULT_CHANNEL_ID, VALID_BR_MAC, TEST_UUID, &info);
161 EXPECT_EQ(SOFTBUS_OK, ret);
162 ret = ClientQueryList(g_validChannelId, nullptr, nullptr, &info);
163 EXPECT_EQ(SOFTBUS_OK, ret);
164 }
165
166 HWTEST_F(BrProxyTest, BrProxyTest004, TestSize.Level1)
167 {
168 int32_t ret = ClientRecordListenerState(g_invalidChannelId, DATA_RECEIVE, true);
169 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
170 ret = ClientRecordListenerState(g_invalidChannelId, LISTENER_TYPE_MAX, true);
171 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
172 ret = ClientRecordListenerState(g_validChannelId, DATA_RECEIVE, true);
173 EXPECT_EQ(SOFTBUS_OK, ret);
174 ret = ClientRecordListenerState(g_validChannelId, CHANNEL_STATE, true);
175 EXPECT_EQ(SOFTBUS_OK, ret);
176 }
177
178 HWTEST_F(BrProxyTest, BrProxyTest005, TestSize.Level1)
179 {
180 bool ret = IsChannelValid(g_invalidChannelId);
181 EXPECT_EQ(false, ret);
182 ret = IsChannelValid(g_validChannelId);
183 EXPECT_EQ(true, ret);
184 }
185
186 HWTEST_F(BrProxyTest, BrProxyTest006, TestSize.Level1)
187 {
188 int32_t ret = ClientDeleteChannelFromList(g_invalidChannelId, nullptr, nullptr);
189 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
190 ret = ClientDeleteChannelFromList(g_validChannelId, nullptr, nullptr);
191 EXPECT_EQ(SOFTBUS_OK, ret);
192 }
193
194 HWTEST_F(BrProxyTest, BrProxyTest007, TestSize.Level1)
195 {
196 int32_t ret = OpenBrProxy(g_sessionId, nullptr, nullptr);
197 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
198 ret = OpenBrProxy(g_sessionId, &g_channelInfo, nullptr);
199 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
200 ret = OpenBrProxy(g_sessionId, nullptr, &g_listener);
201 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
202 NiceMock<BrProxyInterfaceMock> BrProxyMock;
203 EXPECT_CALL(BrProxyMock, GetCallerHapInfo).WillRepeatedly(Return(SOFTBUS_TRANS_TOKEN_HAP_ERR));
204 ret = OpenBrProxy(g_sessionId, &g_channelInfo, &g_listener);
205 EXPECT_EQ(SOFTBUS_TRANS_TOKEN_HAP_ERR, ret);
206 ClientBrProxyChannelInfo info;
207 ret = ClientQueryList(DEFAULT_CHANNEL_ID, VALID_BR_MAC, TEST_UUID, &info);
208 EXPECT_EQ(SOFTBUS_OK, ret);
209 }
210
211
212 HWTEST_F(BrProxyTest, BrProxyTest008, TestSize.Level1)
213 {
214 int32_t ret = ClientTransOnBrProxyOpened(g_validChannelId, nullptr, nullptr, 0);
215 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
216 ret = ClientTransOnBrProxyOpened(g_validChannelId, INVALID_BR_MAC, TEST_UUID, 0);
217 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
218 ret = ClientTransOnBrProxyOpened(g_validChannelId, VALID_BR_MAC, TEST_UUID, 0);
219 EXPECT_EQ(SOFTBUS_OK, ret);
220 ClientBrProxyChannelInfo info;
221 ret = ClientQueryList(DEFAULT_CHANNEL_ID, VALID_BR_MAC, TEST_UUID, &info);
222 EXPECT_EQ(SOFTBUS_OK, ret);
223 ret = ClientQueryList(g_validChannelId, nullptr, nullptr, &info);
224 EXPECT_EQ(SOFTBUS_OK, ret);
225 }
226
227 HWTEST_F(BrProxyTest, BrProxyTest009, TestSize.Level1)
228 {
229 int32_t ret = BrProxyServerInit();
230 EXPECT_EQ(SOFTBUS_OK, ret);
231 }
232
233 HWTEST_F(BrProxyTest, BrProxyTest0010, TestSize.Level1)
234 {
235 ProxyBaseInfo baseInfo;
236 int32_t ret = strcpy_s(baseInfo.brMac, sizeof(baseInfo.brMac), VALID_BR_MAC);
237 EXPECT_EQ(EOK, ret);
238 ret = strcpy_s(baseInfo.uuid, sizeof(baseInfo.uuid), TEST_UUID);
239 EXPECT_EQ(EOK, ret);
240 const char *data = "test";
241 uint32_t dataLen = strlen(data);
242 ret = ServerAddDataToList(nullptr, nullptr, dataLen);
243 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
244 ret = ServerAddDataToList(&baseInfo, nullptr, 0);
245 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
246 ret = ServerAddDataToList(&baseInfo, (const uint8_t *)data, dataLen);
247 EXPECT_EQ(SOFTBUS_OK, ret);
248 uint8_t *qData = nullptr;
249 uint32_t realLen = 0;
250 bool isEmpty;
251 GetDataFromList(&baseInfo, &qData, &realLen, &isEmpty);
252 if (qData != nullptr) {
253 SoftBusFree(qData);
254 qData = nullptr;
255 }
256 EXPECT_EQ(true, dataLen == realLen);
257 EXPECT_EQ(false, isEmpty);
258 GetDataFromList(&baseInfo, &qData, &realLen, &isEmpty);
259 if (qData != nullptr) {
260 SoftBusFree(qData);
261 qData = nullptr;
262 }
263 EXPECT_EQ(true, isEmpty);
264 }
265
266 HWTEST_F(BrProxyTest, BrProxyTest0011, TestSize.Level1)
267 {
268 int32_t ret = ServerAddChannelToList(nullptr, nullptr, g_validChannelId, g_validRequestId);
269 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
270 ret = ServerAddChannelToList(VALID_BR_MAC, TEST_UUID, g_validChannelId, g_validRequestId);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272 ret = ServerDeleteChannelFromList(g_invalidChannelId);
273 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
274 ret = ServerDeleteChannelFromList(g_validChannelId);
275 EXPECT_EQ(SOFTBUS_OK, ret);
276 }
277
278 HWTEST_F(BrProxyTest, BrProxyTest0012, TestSize.Level1)
279 {
280 int32_t ret = ServerAddChannelToList(VALID_BR_MAC, TEST_UUID, g_validChannelId, g_validRequestId);
281 EXPECT_EQ(SOFTBUS_OK, ret);
282 struct ProxyChannel channel;
283 ret = UpdateProxyChannel(INVALID_BR_MAC, TEST_UUID, &channel);
284 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
285 ret = UpdateProxyChannel(VALID_BR_MAC, TEST_UUID, &channel);
286 EXPECT_EQ(SOFTBUS_OK, ret);
287 ret = ServerDeleteChannelFromList(g_validChannelId);
288 EXPECT_EQ(SOFTBUS_OK, ret);
289 }
290
291 HWTEST_F(BrProxyTest, BrProxyTest0013, TestSize.Level1)
292 {
293 ServerBrProxyChannelInfo info;
294 int32_t ret = ServerAddChannelToList(VALID_BR_MAC, TEST_UUID, g_validChannelId, g_validRequestId);
295 EXPECT_EQ(SOFTBUS_OK, ret);
296 ret = GetChannelInfo(INVALID_BR_MAC, TEST_UUID, DEFAULT_INVALID_CHANNEL_ID, DEFAULT_INVALID_REQ_ID, &info);
297 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
298 ret = GetChannelInfo(VALID_BR_MAC, TEST_UUID, DEFAULT_INVALID_CHANNEL_ID, DEFAULT_INVALID_REQ_ID, &info);
299 EXPECT_EQ(SOFTBUS_OK, ret);
300 ret = GetChannelInfo(nullptr, nullptr, g_invalidChannelId, DEFAULT_INVALID_REQ_ID, &info);
301 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_ID, ret);
302 ret = GetChannelInfo(nullptr, nullptr, g_validChannelId, DEFAULT_INVALID_REQ_ID, &info);
303 EXPECT_EQ(SOFTBUS_OK, ret);
304 ret = GetChannelInfo(nullptr, nullptr, DEFAULT_INVALID_CHANNEL_ID, g_invalidRequestId, &info);
305 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
306 ret = GetChannelInfo(nullptr, nullptr, DEFAULT_INVALID_CHANNEL_ID, g_validRequestId, &info);
307 EXPECT_EQ(SOFTBUS_OK, ret);
308 ret = ServerDeleteChannelFromList(g_validChannelId);
309 EXPECT_EQ(SOFTBUS_OK, ret);
310 }
311
312 HWTEST_F(BrProxyTest, BrProxyTest0014, TestSize.Level1)
313 {
314 int32_t ret = ServerAddChannelToList(VALID_BR_MAC, TEST_UUID, g_validChannelId, g_validRequestId);
315 EXPECT_EQ(SOFTBUS_OK, ret);
316 NiceMock<BrProxyInterfaceMock> BrProxyMock;
317 EXPECT_CALL(BrProxyMock, ClientIpcBrProxyOpened).WillRepeatedly(Return(SOFTBUS_OK));
318 struct ProxyChannel channel = {
319 .brMac = "F0:FA:C7:13:56:AB",
320 };
321 onOpenSuccess(g_validRequestId, &channel);
322 ServerBrProxyChannelInfo info;
323 ret = GetChannelInfo(VALID_BR_MAC, TEST_UUID, DEFAULT_INVALID_CHANNEL_ID, DEFAULT_INVALID_REQ_ID, &info);
324 EXPECT_EQ(SOFTBUS_OK, ret);
325 ret = strcmp(info.channel.brMac, "F0:FA:C7:13:56:AB");
326 EXPECT_NE(EOK, ret);
327 ret = memcpy_s(channel.brMac, sizeof(channel.brMac), "F0:FA:C7:13:56:BC", strlen("F0:FA:C7:13:56:BC"));
328 EXPECT_EQ(EOK, ret);
329 onOpenSuccess(g_validRequestId, &channel);
330 ret = GetChannelInfo(VALID_BR_MAC, TEST_UUID, DEFAULT_INVALID_CHANNEL_ID, DEFAULT_INVALID_REQ_ID, &info);
331 EXPECT_EQ(SOFTBUS_OK, ret);
332 ret = ServerDeleteChannelFromList(g_validChannelId);
333 EXPECT_EQ(SOFTBUS_OK, ret);
334 }
335
336 HWTEST_F(BrProxyTest, BrProxyTest0015, TestSize.Level1)
337 {
338 ServerBrProxyChannelInfo info;
339 int32_t ret = ServerAddChannelToList(VALID_BR_MAC, TEST_UUID, g_validChannelId, g_validRequestId);
340 EXPECT_EQ(SOFTBUS_OK, ret);
341 NiceMock<BrProxyInterfaceMock> BrProxyMock;
342 EXPECT_CALL(BrProxyMock, ClientIpcBrProxyOpened).WillRepeatedly(Return(SOFTBUS_OK));
343 onOpenFail(g_invalidRequestId, 0);
344 ret = GetChannelInfo(nullptr, nullptr, g_validChannelId, DEFAULT_INVALID_REQ_ID, &info);
345 EXPECT_EQ(SOFTBUS_OK, ret);
346 onOpenFail(g_validRequestId, 0);
347 ret = GetChannelInfo(nullptr, nullptr, g_validChannelId, DEFAULT_INVALID_REQ_ID, &info);
348 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_ID, ret);
349 ret = ServerDeleteChannelFromList(g_validChannelId);
350 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
351 }
352
353 HWTEST_F(BrProxyTest, BrProxyTest0016, TestSize.Level1)
354 {
355 int32_t ret = TransCloseBrProxy(-1, false);
356 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
357 }
358
359 HWTEST_F(BrProxyTest, BrProxyTest0017, TestSize.Level1)
360 {
361 int32_t ret = TransClientInit();
362 ASSERT_TRUE(ret == SOFTBUS_OK);
363 ret = ClientAddChannelToList(SESSION_ID, &g_channelInfo, &g_listener);
364 ASSERT_TRUE(ret == SOFTBUS_OK);
365 ret = ClientUpdateList(g_channelInfo.peerBRMacAddr, g_channelInfo.peerBRUuid, CHANNEL_ID);
366 ASSERT_TRUE(ret == SOFTBUS_OK);
367 ret = ClientTransBrProxyChannelChange(CHANNEL_ID, 0);
368 EXPECT_EQ(SOFTBUS_OK, ret);
369 }
370
371 HWTEST_F(BrProxyTest, BrProxyTest0018, TestSize.Level1)
372 {
373 int32_t ret = ClientTransBrProxyDataReceived(CHANNEL_ID_ERR, nullptr, 0);
374 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
375 ret = ClientTransBrProxyDataReceived(CHANNEL_ID, nullptr, 0);
376 EXPECT_EQ(SOFTBUS_OK, ret);
377 }
378 }