1 /*
2 * Copyright (c) 2025 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 <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "accesstoken_kit.h"
21 #include "br_proxy.c"
22 #include "br_proxy_common.h"
23 #include "br_proxy_ext_test_mock.h"
24 #include "br_proxy_server_manager_mock.h"
25 #include "br_proxy_server_manager.c"
26 #include "message_handler.h"
27 #include "nativetoken_kit.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_common.h"
30 #include "softbus_conn_interface.h"
31 #include "softbus_def.h"
32 #include "softbus_error_code.h"
33 #include "token_setproc.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 #define CHANNEL_ID 5
40 #define CHANNEL_ID_ERR 0
41 #define SESSION_ID 2
42 #define REQUEST_ID 6
43 #define PID_TEST 1111
44 #define UID_TEST 2222
45 #define TOKENID_TEST 3333
46 const char *TEST_UUID = "0000FEEA-0000-1000-8000-00805F9B34FB";
47 const char *VALID_BR_MAC = "F0:FA:C7:13:56:BC";
48 const char *INVALID_BR_MAC = "F0:FA:C7:13:56:AB";
49
50 class BrProxyServerManagerTest : public testing::Test {
51 public:
BrProxyServerManagerTest()52 BrProxyServerManagerTest()
53 {}
~BrProxyServerManagerTest()54 ~BrProxyServerManagerTest()
55 {}
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
SetUp()58 void SetUp() override
59 {}
TearDown()60 void TearDown() override
61 {}
62 };
63
SetUpTestCase(void)64 void BrProxyServerManagerTest::SetUpTestCase(void)
65 {
66 }
67
TearDownTestCase(void)68 void BrProxyServerManagerTest::TearDownTestCase(void)
69 {
70 }
71
72 /**
73 * @tc.name: BrProxyServerManagerTest000
74 * @tc.desc: BrProxyServerManagerTest000, use the Normal parameter.
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest000, TestSize.Level1)
79 {
80 int32_t ret = GetServerListCount(nullptr);
81 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
82 g_serverList = NULL;
83 int32_t count = 0;
84 ret = GetServerListCount(&count);
85 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
86 ret = BrProxyServerInit();
87 ASSERT_TRUE(ret == SOFTBUS_OK);
88 ret = GetServerListCount(&count);
89 EXPECT_EQ(SOFTBUS_OK, ret);
90 }
91
92 /**
93 * @tc.name: BrProxyServerManagerTest001
94 * @tc.desc: BrProxyServerManagerTest001, use the Normal parameter.
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest001, TestSize.Level1)
99 {
100 BrProxyChannelInfo info = {
101 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
102 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
103 };
104 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
105 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
106 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
107 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
108 int32_t ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
109 EXPECT_EQ(SOFTBUS_OK, ret);
110 }
111
112 /**
113 * @tc.name: BrProxyServerManagerTest002
114 * @tc.desc: BrProxyServerManagerTest002, use the normal parameter.
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest002, TestSize.Level1)
119 {
120 int32_t channelId = 0;
121 int32_t ret = GetChannelIdFromServerList(&channelId);
122 EXPECT_EQ(SOFTBUS_OK, ret);
123 ret = GetNewChannelId(&channelId);
124 EXPECT_EQ(SOFTBUS_OK, ret);
125 CloseAllConnect();
126 LnnEventBasicInfo info;
127 info.event = LNN_EVENT_USER_SWITCHED;
128 UserSwitchedHandler(&info);
129 }
130
131 /**
132 * @tc.name: BrProxyServerManagerTest003
133 * @tc.desc: BrProxyServerManagerTest003
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest003, TestSize.Level1)
138 {
139 const char *bundleName = "com.example.test";
140 g_proxyList = NULL;
141 bool ret = IsBrProxy(bundleName);
142 EXPECT_EQ(false, ret);
143 }
144
145 /**
146 * @tc.name: BrProxyServerManagerTest004
147 * @tc.desc: BrProxyServerManagerTest004
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest004, TestSize.Level1)
152 {
153 g_serverList = NULL;
154 int32_t channelId = 0;
155 int32_t ret = GetChannelIdFromServerList(&channelId);
156 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
157 ret = BrProxyServerInit();
158 EXPECT_EQ(SOFTBUS_OK, ret);
159 BrProxyChannelInfo info;
160 (void) strcpy_s(info.peerBRMacAddr, sizeof(info.peerBRMacAddr), VALID_BR_MAC);
161 (void) strcpy_s(info.peerBRUuid, sizeof(info.peerBRUuid), TEST_UUID);
162 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
163 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
164 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
165 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
166 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
167 EXPECT_EQ(SOFTBUS_OK, ret);
168 ret = GetChannelIdFromServerList(&channelId);
169 EXPECT_EQ(SOFTBUS_OK, ret);
170 ret = GetChannelIdFromServerList(nullptr);
171 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
172 }
173
174 /**
175 * @tc.name: BrProxyServerManagerTest005
176 * @tc.desc: BrProxyServerManagerTest005
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest005, TestSize.Level1)
181 {
182 g_proxyList = NULL;
183 int32_t ret = CloseAllBrProxy();
184 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
185 ret = BrProxyServerInit();
186 EXPECT_EQ(SOFTBUS_OK, ret);
187 ret = CloseAllBrProxy();
188 EXPECT_EQ(SOFTBUS_OK, ret);
189 BrProxyChannelInfo info1;
190 (void) strcpy_s(info1.peerBRMacAddr, sizeof(info1.peerBRMacAddr), VALID_BR_MAC);
191 (void) strcpy_s(info1.peerBRUuid, sizeof(info1.peerBRUuid), TEST_UUID);
192 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
193 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
194 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
195 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
196 ret = ServerAddChannelToList(info1.peerBRMacAddr, info1.peerBRUuid, CHANNEL_ID, REQUEST_ID);
197 EXPECT_EQ(SOFTBUS_OK, ret);
198 BrProxyChannelInfo info2;
199 (void) strcpy_s(info2.peerBRMacAddr, sizeof(info2.peerBRMacAddr), "FF:AA:CC:AA:BB:DD");
200 (void) strcpy_s(info2.peerBRUuid, sizeof(info2.peerBRUuid), "BBBBBBBB-0000-0000-8888-BBBBBBBBBBBB");
201 ret = ServerAddChannelToList(info2.peerBRMacAddr, info2.peerBRUuid, CHANNEL_ID + 1, REQUEST_ID + 1);
202 EXPECT_EQ(SOFTBUS_OK, ret);
203 ret = CloseAllBrProxy();
204 EXPECT_EQ(SOFTBUS_OK, ret);
205 }
206
207 /**
208 * @tc.name: BrProxyServerManagerTest006
209 * @tc.desc: BrProxyServerManagerTest006
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest006, TestSize.Level1)
214 {
215 bool result = PermissionCheckPass(nullptr);
216 EXPECT_FALSE(result);
217 }
218
219 /**
220 * @tc.name: BrProxyServerManagerTest007
221 * @tc.desc: BrProxyServerManagerTest007
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest007, TestSize.Level1)
226 {
227 int32_t channelId = 0;
228 int32_t ret = GetNewChannelId(nullptr);
229 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
230 ret = GetNewChannelId(&channelId);
231 EXPECT_EQ(SOFTBUS_OK, ret);
232 }
233
234 /**
235 * @tc.name: BrProxyServerManagerTest008
236 * @tc.desc: BrProxyServerManagerTest008
237 * @tc.type: FUNC
238 * @tc.require:
239 */
240 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest008, TestSize.Level1)
241 {
242 uint32_t dataLen = 8;
243 int32_t ret = ServerAddDataToList(nullptr, nullptr, dataLen);
244 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
245 ProxyBaseInfo *baseInfo = NULL;
246 const uint8_t *data = reinterpret_cast<const uint8_t *>("Test data");
247 ret = ServerAddDataToList(nullptr, data, dataLen);
248 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
249 ret = ServerAddDataToList(baseInfo, nullptr, dataLen);
250 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
251 }
252
253 /**
254 * @tc.name: BrProxyServerManagerTest009
255 * @tc.desc: BrProxyServerManagerTest009
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest009, TestSize.Level1)
260 {
261 int32_t ret = UpdateConnectState(nullptr, TEST_UUID, IS_CONNECTED);
262 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
263 g_proxyList = NULL;
264 ret = UpdateConnectState(VALID_BR_MAC, TEST_UUID, IS_CONNECTED);
265 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
266 }
267
268 /**
269 * @tc.name: BrProxyServerManagerTest010
270 * @tc.desc: BrProxyServerManagerTest010
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest010, TestSize.Level1)
275 {
276 bool ret = IsBrProxyExist(nullptr, TEST_UUID);
277 EXPECT_FALSE(ret);
278 ret = IsBrProxyExist(VALID_BR_MAC, nullptr);
279 EXPECT_FALSE(ret);
280 g_proxyList = NULL;
281 ret = IsBrProxyExist(VALID_BR_MAC, TEST_UUID);
282 EXPECT_FALSE(ret);
283 }
284
285 /**
286 * @tc.name: BrProxyServerManagerTest011
287 * @tc.desc: BrProxyServerManagerTest011
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest011, TestSize.Level1)
292 {
293 int32_t ret = GetCallerInfoAndVerifyPermission(nullptr);
294 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
295 }
296
297 /**
298 * @tc.name: BrProxyServerManagerTest012
299 * @tc.desc: BrProxyServerManagerTest012
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest012, TestSize.Level1)
304 {
305 int32_t ret = ServerAddProxyToList(nullptr, TEST_UUID);
306 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
307 ret = ServerAddProxyToList(VALID_BR_MAC, nullptr);
308 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
309 g_proxyList = NULL;
310 ret = ServerAddProxyToList(VALID_BR_MAC, TEST_UUID);
311 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
312 }
313
314 /**
315 * @tc.name: BrProxyServerManagerTest013
316 * @tc.desc: BrProxyServerManagerTest013
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest013, TestSize.Level1)
321 {
322 g_proxyList = NULL;
323 int32_t ret = ServerDeleteProxyFromList(VALID_BR_MAC, TEST_UUID);
324 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
325 }
326
327 /**
328 * @tc.name: BrProxyServerManagerTest014
329 * @tc.desc: BrProxyServerManagerTest014
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest014, TestSize.Level1)
334 {
335 int32_t ret = BrProxyServerInit();
336 EXPECT_EQ(SOFTBUS_OK, ret);
337 BrProxyChannelInfo info;
338 (void) strcpy_s(info.peerBRMacAddr, sizeof(info.peerBRMacAddr), VALID_BR_MAC);
339 (void) strcpy_s(info.peerBRUuid, sizeof(info.peerBRUuid), TEST_UUID);
340 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
341 EXPECT_EQ(SOFTBUS_OK, ret);
342 bool result = IsSessionExist(nullptr, TEST_UUID);
343 EXPECT_FALSE(result);
344 result = IsSessionExist(VALID_BR_MAC, nullptr);
345 EXPECT_FALSE(result);
346 SoftBusList* temp = g_serverList;
347 g_serverList = NULL;
348 result = IsSessionExist(VALID_BR_MAC, TEST_UUID);
349 EXPECT_FALSE(result);
350 g_serverList = temp;
351 result = IsSessionExist(VALID_BR_MAC, TEST_UUID);
352 EXPECT_TRUE(result);
353 ret = ServerDeleteChannelFromList(CHANNEL_ID);
354 EXPECT_EQ(SOFTBUS_OK, ret);
355 }
356
357 /**
358 * @tc.name: BrProxyServerManagerTest015
359 * @tc.desc: BrProxyServerManagerTest015
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest015, TestSize.Level1)
364 {
365 g_serverList = NULL;
366 int32_t ret = ServerDeleteChannelFromList(CHANNEL_ID);
367 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
368 }
369
370 /**
371 * @tc.name: BrProxyServerManagerTest016
372 * @tc.desc: BrProxyServerManagerTest016
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest016, TestSize.Level1)
377 {
378 struct ProxyChannel channel;
379 g_serverList = NULL;
380 int32_t ret = UpdateProxyChannel(VALID_BR_MAC, TEST_UUID, &channel);
381 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
382 }
383
384 /**
385 * @tc.name: BrProxyServerManagerTest017
386 * @tc.desc: BrProxyServerManagerTest017
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest017, TestSize.Level1)
391 {
392 pid_t uid = 1;
393 bool ret = TransIsProxyChannelEnabled(uid);
394 EXPECT_EQ(ret, true);
395 ret = TransIsProxyChannelEnabled(uid);
396 EXPECT_EQ(ret, true);
397 }
398
399 /**
400 * @tc.name: BrProxyServerManagerTest018
401 * @tc.desc: BrProxyServerManagerTest018
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest018, TestSize.Level1)
406 {
407 pid_t uid = 1;
408 int32_t ret = RetryListInit();
409 EXPECT_EQ(ret, SOFTBUS_OK);
410 int32_t result = AddToRetryList(uid);
411 EXPECT_EQ(result, SOFTBUS_OK);
412 ClearCountInRetryList(uid);
413 g_retryList = NULL;
414 }
415
416 /**
417 * @tc.name: BrProxyServerManagerTest019
418 * @tc.desc: BrProxyServerManagerTest019
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest019, TestSize.Level1)
423 {
424 pid_t uid = 1;
425 uint32_t cnt = 0;
426 int32_t ret = GetCountFromRetryList(uid, &cnt);
427 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
428 ret = RetryListInit();
429 EXPECT_EQ(ret, SOFTBUS_OK);
430 ret = GetCountFromRetryList(uid, NULL);
431 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
432 ret = AddToRetryList(uid);
433 EXPECT_EQ(ret, SOFTBUS_OK);
434 ret = GetCountFromRetryList(uid, &cnt);
435 EXPECT_EQ(ret, SOFTBUS_OK);
436 g_retryList = NULL;
437 }
438
439 /**
440 * @tc.name: BrProxyServerManagerTest020
441 * @tc.desc: BrProxyServerManagerTest020
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest020, TestSize.Level1)
446 {
447 pid_t uid = 1;
448 int32_t ret = AddToRetryList(uid);
449 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
450 ret = RetryListInit();
451 EXPECT_EQ(ret, SOFTBUS_OK);
452 ret = AddToRetryList(uid);
453 EXPECT_EQ(ret, SOFTBUS_OK);
454 ret = AddToRetryList(uid);
455 EXPECT_EQ(ret, SOFTBUS_OK);
456 g_retryList = NULL;
457 }
458
459 /**
460 * @tc.name: BrProxyServerManagerTest021
461 * @tc.desc: BrProxyServerManagerTest021
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest021, TestSize.Level1)
466 {
467 pid_t uid = 1;
468 bool ret = IsUidExist(uid);
469 EXPECT_EQ(ret, false);
470 int32_t result = RetryListInit();
471 EXPECT_EQ(result, SOFTBUS_OK);
472 ret = IsUidExist(uid);
473 EXPECT_EQ(ret, false);
474 result = AddToRetryList(uid);
475 EXPECT_EQ(result, SOFTBUS_OK);
476 ret = IsUidExist(uid);
477 EXPECT_EQ(ret, true);
478 }
479
480 /**
481 * @tc.name: BrProxyServerManagerTest022
482 * @tc.desc: BrProxyServerManagerTest022
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest022, TestSize.Level1)
487 {
488 int32_t ret = RetryListInit();
489 EXPECT_EQ(ret, SOFTBUS_OK);
490 ret = RetryListInit();
491 EXPECT_EQ(ret, SOFTBUS_OK);
492 }
493
494 /**
495 * @tc.name: BrProxyServerManagerTest023
496 * @tc.desc: BrProxyServerManagerTest023
497 * @tc.type: FUNC
498 * @tc.require:
499 */
500 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest023, TestSize.Level1)
501 {
502 const char *brMac = "";
503 const char *uuid = "";
504 int32_t channelId = 1;
505 uint32_t requestId = 1;
506 ServerBrProxyChannelInfo info = { 0 };
507 int32_t ret = GetChannelInfo(brMac, uuid, channelId, requestId, &info);
508 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
509 ret = BrProxyServerInit();
510 ASSERT_EQ(ret, SOFTBUS_OK);
511 ret = GetChannelInfo(brMac, uuid, channelId, requestId, &info);
512 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_CHANNEL_ID);
513 channelId = -1;
514 ret = GetChannelInfo(brMac, uuid, channelId, requestId, &info);
515 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
516 }
517
518 /**
519 * @tc.name: BrProxyServerManagerTest024
520 * @tc.desc: BrProxyServerManagerTest024
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest024, TestSize.Level1)
525 {
526 const char *mac = "11:33:44:22:33:56";
527 const char *uuid = "testuuid";
528 int32_t channelId = 1;
529 int32_t arr = GetChannelId(NULL, uuid, &channelId);
530 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
531 arr = GetChannelId(mac, NULL, &channelId);
532 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
533 g_proxyList = NULL;
534 arr = GetChannelId(mac, uuid, &channelId);
535 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
536 int32_t ret = BrProxyServerInit();
537 ASSERT_EQ(ret, SOFTBUS_OK);
538 arr = GetChannelId(mac, uuid, NULL);
539 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
540 arr = GetChannelId(NULL, NULL, &channelId);
541 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
542 arr = GetChannelId(NULL, NULL, &channelId);
543 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
544 arr = GetChannelId(NULL, NULL, &channelId);
545 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
546 arr = GetChannelId(NULL, NULL, NULL);
547 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
548 }
549
550 /**
551 * @tc.name: BrProxyServerManagerTest025
552 * @tc.desc: BrProxyServerManagerTest025
553 * @tc.type: FUNC
554 * @tc.require:
555 */
556 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest025, TestSize.Level1)
557 {
558 const char *mac = "11:33:44:22:33:56";
559 const char *uuid = "testuuid";
560 int32_t channelId = 1;
561 int32_t arr = GetChannelId(NULL, uuid, &channelId);
562 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
563 arr = GetChannelId(mac, NULL, &channelId);
564 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
565 arr = GetChannelId(mac, uuid, NULL);
566 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
567 arr = GetChannelId(NULL, NULL, &channelId);
568 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
569 arr = GetChannelId(mac, NULL, NULL);
570 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
571 arr = GetChannelId(NULL, NULL, NULL);
572 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
573 arr = GetChannelId(NULL, uuid, NULL);
574 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
575 }
576
577 /**
578 * @tc.name: BrProxyServerManagerTest026
579 * @tc.desc: BrProxyServerManagerTest026
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest026, TestSize.Level1)
584 {
585 const char *mac = "11:33:44:22:33:56";
586 const char *uuid = "testuuid";
587 int32_t arr = TransOpenBrProxy(NULL, uuid);
588 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
589 arr = TransOpenBrProxy(mac, NULL);
590 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
591 arr = TransOpenBrProxy(NULL, NULL);
592 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
593 }
594
595 /**
596 * @tc.name: BrProxyServerManagerTest027
597 * @tc.desc: BrProxyServerManagerTest027
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest027, TestSize.Level1)
602 {
603 const char *mac = "11:33:44:22:33:56";
604 const char *uid = "testuuid";
605 int32_t channelId = 1;
606 uint32_t requestId = 0;
607 int32_t arr = ServerAddChannelToList(NULL, uid, channelId, requestId);
608 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
609 arr = ServerAddChannelToList(mac, NULL, channelId, requestId);
610 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
611 g_serverList = NULL;
612 arr = ServerAddChannelToList(mac, uid, channelId, requestId);
613 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
614 arr = ServerAddChannelToList(NULL, uid, channelId, requestId);
615 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
616 arr = ServerAddChannelToList(mac, NULL, channelId, requestId);
617 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
618 arr = ServerAddChannelToList(mac, NULL, channelId, requestId);
619 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
620 int32_t ret = BrProxyServerInit();
621 ASSERT_EQ(ret, SOFTBUS_OK);
622 arr = ServerAddChannelToList(NULL, NULL, channelId, requestId);
623 EXPECT_EQ(arr, SOFTBUS_INVALID_PARAM);
624 }
625
626 /**
627 * @tc.name: BrProxyServerManagerTest028
628 * @tc.desc: BrProxyServerManagerTest028
629 * @tc.type: FUNC
630 * @tc.require:
631 */
632 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest028, TestSize.Level1)
633 {
634 int32_t ret = BrProxyServerInit();
635 EXPECT_EQ(SOFTBUS_OK, ret);
636 }
637
638 /**
639 * @tc.name: BrProxyServerManagerTest029
640 * @tc.desc: BrProxyServerManagerTest029
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest029, TestSize.Level1)
645 {
646 BrProxyInfo info;
647 int32_t ret = BrProxyServerInit();
648 EXPECT_EQ(SOFTBUS_OK, ret);
649 ret = GetBrProxy(nullptr, TEST_UUID, &info);
650 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
651 ret = GetBrProxy(VALID_BR_MAC, nullptr, &info);
652 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
653 g_proxyList = nullptr;
654 ret = GetBrProxy(VALID_BR_MAC, TEST_UUID, &info);
655 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
656 ret = BrProxyServerInit();
657 EXPECT_EQ(ret, SOFTBUS_OK);
658 ret = GetBrProxy(VALID_BR_MAC, TEST_UUID, nullptr);
659 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
660 }
661
662 /**
663 * @tc.name: BrProxyServerManagerTest030
664 * @tc.desc: BrProxyServerManagerTest030
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest030, TestSize.Level1)
669 {
670 struct ProxyChannel channel;
671 int32_t ret = BrProxyServerInit();
672 EXPECT_EQ(SOFTBUS_OK, ret);
673 ret = UpdateBrProxy(nullptr, TEST_UUID, &channel, true, CHANNEL_ID);
674 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
675 ret = UpdateBrProxy(VALID_BR_MAC, nullptr, &channel, true, CHANNEL_ID);
676 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
677 g_proxyList = nullptr;
678 ret = UpdateBrProxy(VALID_BR_MAC, TEST_UUID, &channel, true, CHANNEL_ID);
679 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
680 ret = BrProxyServerInit();
681 EXPECT_EQ(ret, SOFTBUS_OK);
682 ret = UpdateBrProxy(VALID_BR_MAC, TEST_UUID, nullptr, true, CHANNEL_ID);
683 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
684 }
685
686 /**
687 * @tc.name: BrProxyServerManagerTest031
688 * @tc.desc: BrProxyServerManagerTest031
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest031, TestSize.Level1)
693 {
694 pid_t uid = 12345;
695 g_proxyList = NULL;
696 bool ret = IsBrProxyEnable(uid);
697 EXPECT_FALSE(ret);
698 }
699
700 /**
701 * @tc.name: BrProxyServerManagerTest032
702 * @tc.desc: BrProxyServerManagerTest032
703 * @tc.type: FUNC
704 * @tc.require:
705 */
706 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest032, TestSize.Level1)
707 {
708 g_serverList = NULL;
709 int32_t ret = BrProxyServerInit();
710 ASSERT_TRUE(ret == SOFTBUS_OK);
711 BrProxyChannelInfo info = {
712 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
713 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
714 };
715 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
716 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
717 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
718 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
719 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
720 EXPECT_EQ(SOFTBUS_OK, ret);
721 ret = ServerDeleteChannelFromList(CHANNEL_ID);
722 EXPECT_EQ(SOFTBUS_OK, ret);
723 }
724
725 /**
726 * @tc.name: BrProxyServerManagerTest033
727 * @tc.desc: BrProxyServerManagerTest033
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest033, TestSize.Level1)
732 {
733 g_serverList = NULL;
734 int32_t ret = BrProxyServerInit();
735 ASSERT_TRUE(ret == SOFTBUS_OK);
736 BrProxyChannelInfo info = {
737 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
738 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
739 };
740 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
741 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
742 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
743 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
744 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
745 EXPECT_EQ(SOFTBUS_OK, ret);
746 ServerDeleteChannelByPid(PID_TEST);
747 EXPECT_EQ(g_serverList->cnt, 0);
748 }
749
750 /**
751 * @tc.name: BrProxyServerManagerTest034
752 * @tc.desc: BrProxyServerManagerTest034
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest034, TestSize.Level1)
757 {
758 g_proxyList = NULL;
759 bool result = CheckSessionExistByUid(UID_TEST);
760 EXPECT_EQ(false, result);
761 int32_t ret = BrProxyServerInit();
762 ASSERT_TRUE(ret == SOFTBUS_OK);
763 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
764 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
765 ret = ServerAddProxyToList(VALID_BR_MAC, TEST_UUID);
766 EXPECT_NE(SOFTBUS_OK, ret);
767 result = CheckSessionExistByUid(UID_TEST);
768 EXPECT_EQ(result, IS_DISCONNECTED);
769 }
770
771 /**
772 * @tc.name: BrProxyServerManagerTest035
773 * @tc.desc: BrProxyServerManagerTest035
774 * @tc.type: FUNC
775 * @tc.require:
776 */
777 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest035, TestSize.Level1)
778 {
779 g_serverList = NULL;
780 int32_t ret = TransSetListenerState(CHANNEL_ID, 0, false);
781 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
782 ret = BrProxyServerInit();
783 ASSERT_TRUE(ret == SOFTBUS_OK);
784 BrProxyChannelInfo info = {
785 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
786 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
787 };
788 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
789 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
790 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
791 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
792 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
793 EXPECT_EQ(SOFTBUS_OK, ret);
794 ret = TransSetListenerState(CHANNEL_ID, 0, false);
795 EXPECT_EQ(SOFTBUS_OK, ret);
796 }
797
798 /**
799 * @tc.name: BrProxyServerManagerTest036
800 * @tc.desc: BrProxyServerManagerTest036
801 * @tc.type: FUNC
802 * @tc.require:
803 */
804 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest036, TestSize.Level1)
805 {
806 g_serverList = NULL;
807 int32_t ret = BrProxyServerInit();
808 ASSERT_TRUE(ret == SOFTBUS_OK);
809 BrProxyChannelInfo info = {
810 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
811 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
812 };
813 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
814 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
815 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
816 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
817 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
818 EXPECT_EQ(SOFTBUS_OK, ret);
819 ret = SetListenerStateByChannelId(CHANNEL_ID, DATA_RECEIVE, true);
820 EXPECT_EQ(SOFTBUS_OK, ret);
821 pid_t result = PID_TEST;
822 ProxyBaseInfo info2 = {
823 .brMac = "FF:AA:CC:AA:BB:CC",
824 .uuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
825 };
826 int32_t channelId = CHANNEL_ID;
827 ret = SelectClient(&info2, &result, &channelId);
828 EXPECT_EQ(SOFTBUS_OK, ret);
829 }
830
831 /**
832 * @tc.name: BrProxyServerManagerTest037
833 * @tc.desc: BrProxyServerManagerTest037
834 * @tc.type: FUNC
835 * @tc.require:
836 */
837 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest037, TestSize.Level1)
838 {
839 g_serverList = NULL;
840 int32_t ret = BrProxyServerInit();
841 ASSERT_TRUE(ret == SOFTBUS_OK);
842 BrProxyChannelInfo info = {
843 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
844 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
845 };
846 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
847 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
848 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
849 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
850 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
851 EXPECT_EQ(SOFTBUS_OK, ret);
852 pid_t result = PID_TEST;
853 ProxyBaseInfo info2 = {
854 .brMac = "FF:AA:CC:AA:BB:CC",
855 .uuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
856 };
857 int32_t channelId = CHANNEL_ID;
858 ret = SelectClient(&info2, &result, &channelId);
859 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
860 }
861
862 /**
863 * @tc.name: BrProxyServerManagerTest038
864 * @tc.desc: BrProxyServerManagerTest038
865 * @tc.type: FUNC
866 * @tc.require:
867 */
868 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest038, TestSize.Level1)
869 {
870 g_serverList = NULL;
871 int32_t ret = BrProxyServerInit();
872 ASSERT_TRUE(ret == SOFTBUS_OK);
873 BrProxyChannelInfo info = {
874 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
875 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
876 };
877 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
878 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
879 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
880 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
881 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
882 EXPECT_EQ(SOFTBUS_OK, ret);
883 ret = SetListenerStateByChannelId(CHANNEL_ID, DATA_RECEIVE, true);
884 EXPECT_EQ(SOFTBUS_OK, ret);
885 pid_t result = PID_TEST;
886 ProxyBaseInfo info2 = {
887 .brMac = "a",
888 .uuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
889 };
890 int32_t channelId = CHANNEL_ID;
891 ret = SelectClient(&info2, &result, &channelId);
892 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
893 info2 = {
894 .brMac = "FF:AA:CC:AA:BB:CC",
895 .uuid = "b",
896 };
897 ret = SelectClient(&info2, &result, &channelId);
898 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
899 }
900
901 /**
902 * @tc.name: BrProxyServerManagerTest039
903 * @tc.desc: BrProxyServerManagerTest039
904 * @tc.type: FUNC
905 * @tc.require:
906 */
907 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest039, TestSize.Level1)
908 {
909 bool isEnable = true;
910 int32_t ret = BrProxyServerInit();
911 EXPECT_EQ(SOFTBUS_OK, ret);
912 ListenerType type = LISTENER_TYPE_MAX;
913 ret = SetListenerStateByChannelId(CHANNEL_ID, type, isEnable);
914 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
915 g_serverList = NULL;
916 ret = SetListenerStateByChannelId(CHANNEL_ID, type, isEnable);
917 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
918 ret = BrProxyServerInit();
919 EXPECT_EQ(SOFTBUS_OK, ret);
920 BrProxyChannelInfo info = {
921 .peerBRMacAddr = "FF:AA:CC:AA:BB:CC",
922 .peerBRUuid = "AAAAAAAA-0000-0000-8888-BBBBBBBBBBBB",
923 };
924 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
925 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
926 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
927 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
928 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
929 EXPECT_EQ(SOFTBUS_OK, ret);
930 type = DATA_RECEIVE;
931 ret = SetListenerStateByChannelId(CHANNEL_ID, type, isEnable);
932 EXPECT_EQ(SOFTBUS_OK, ret);
933 type = CHANNEL_STATE;
934 ret = SetListenerStateByChannelId(CHANNEL_ID, type, isEnable);
935 EXPECT_EQ(SOFTBUS_OK, ret);
936 ret = SetListenerStateByChannelId(CHANNEL_ID_ERR, type, isEnable);
937 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
938 }
939
940 /**
941 * @tc.name: BrProxyServerManagerTest040
942 * @tc.desc: BrProxyServerManagerTest040
943 * @tc.type: FUNC
944 * @tc.require:
945 */
946 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest040, TestSize.Level1)
947 {
948 int32_t ret = BrProxyServerInit();
949 ASSERT_EQ(SOFTBUS_OK, ret);
950 ret = TransSendBrProxyData(CHANNEL_ID, nullptr, 0);
951 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
952 }
953
954 /**
955 * @tc.name: BrProxyServerManagerTest041
956 * @tc.desc: BrProxyServerManagerTest041
957 * @tc.type: FUNC
958 * @tc.require:
959 */
960 HWTEST_F(BrProxyServerManagerTest, BrProxyServerManagerTest041, TestSize.Level1)
961 {
962 g_serverList = nullptr;
963 ProxyBaseInfo baseInfo;
964 (void) strcpy_s(baseInfo.brMac, sizeof(baseInfo.brMac), VALID_BR_MAC);
965 (void) strcpy_s(baseInfo.uuid, sizeof(baseInfo.uuid), TEST_UUID);
966 bool result = IsForegroundProcess(&baseInfo);
967 EXPECT_FALSE(result);
968 int32_t ret = BrProxyServerInit();
969 ASSERT_EQ(SOFTBUS_OK, ret);
970 result = IsForegroundProcess(&baseInfo);
971 EXPECT_FALSE(result);
972 BrProxyChannelInfo info;
973 (void) strcpy_s(info.peerBRMacAddr, sizeof(info.peerBRMacAddr), VALID_BR_MAC);
974 (void) strcpy_s(info.peerBRUuid, sizeof(info.peerBRUuid), TEST_UUID);
975 NiceMock<BrProxyServerManagerInterfaceMock> brProxyServerManagerMock;
976 EXPECT_CALL(brProxyServerManagerMock, GetCallerPid).WillRepeatedly(Return(PID_TEST));
977 EXPECT_CALL(brProxyServerManagerMock, GetCallerUid).WillRepeatedly(Return(UID_TEST));
978 EXPECT_CALL(brProxyServerManagerMock, GetCallerTokenId).WillRepeatedly(Return(TOKENID_TEST));
979 ret = ServerAddChannelToList(info.peerBRMacAddr, info.peerBRUuid, CHANNEL_ID, REQUEST_ID);
980 ASSERT_EQ(SOFTBUS_OK, ret);
981 result = IsForegroundProcess(&baseInfo);
982 EXPECT_TRUE(result);
983 BrProxyChannelInfo infoMismatch;
984 (void) strcpy_s(infoMismatch.peerBRMacAddr, sizeof(infoMismatch.peerBRMacAddr), "FF:AA:CC:AA:BB:DD");
985 (void) strcpy_s(infoMismatch.peerBRUuid, sizeof(infoMismatch.peerBRUuid), "BBBBBBBB-0000-0000-8888-BBBBBBBBBBBB");
986 ret = ServerAddChannelToList(infoMismatch.peerBRMacAddr, infoMismatch.peerBRUuid, CHANNEL_ID + 1, REQUEST_ID + 1);
987 ASSERT_EQ(SOFTBUS_OK, ret);
988 result = IsForegroundProcess(&baseInfo);
989 EXPECT_TRUE(result);
990 ret = ServerDeleteChannelFromList(CHANNEL_ID);
991 ASSERT_EQ(SOFTBUS_OK, ret);
992 ret = ServerDeleteChannelFromList(CHANNEL_ID + 1);
993 ASSERT_EQ(SOFTBUS_OK, ret);
994 result = IsForegroundProcess(&baseInfo);
995 EXPECT_FALSE(result);
996 }
997 }