1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17
18 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20
21 #ifdef GTEST_API_
22 #define private public
23 #endif
24
25 #include "conn_manager.h"
26 #include "net_conn_manager_test_util.h"
27 #include "net_manager_constants.h"
28 #include "netnative_log_wrapper.h"
29 #include "netsys_native_service_proxy.h"
30 #include "network_permission.h"
31
32 namespace OHOS {
33 namespace NetsysNative {
34 using namespace testing::ext;
35 using namespace NetManagerStandard;
36 using namespace NetConnManagerTestUtil;
37 constexpr int32_t NETID = 103;
38 const std::string INTERFACENAME = "wlan0";
39 constexpr int32_t INTERNAL_NETID = 10;
40 const std::string INTERNAL_INTERFACENAME = "rmnet0";
41 constexpr int32_t LOCAL_NET_ID = 99;
42 constexpr int32_t ERROR_CODE = -101;
43 constexpr int32_t INVALID_VALUE = -1;
44
45 class ConnManagerTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 static inline std::shared_ptr<ConnManager> instance_ = nullptr;
52 };
53
SetUpTestCase()54 void ConnManagerTest::SetUpTestCase()
55 {
56 instance_ = std::make_shared<ConnManager>();
57 }
58
TearDownTestCase()59 void ConnManagerTest::TearDownTestCase()
60 {
61 instance_ = nullptr;
62 }
63
SetUp()64 void ConnManagerTest::SetUp() {}
65
TearDown()66 void ConnManagerTest::TearDown() {}
67
68 /**
69 * @tc.name: SetInternetPermission001
70 * @tc.desc: Test ConnManager SetInternetPermission.
71 * @tc.type: FUNC
72 */
73 HWTEST_F(ConnManagerTest, SetInternetPermission001, TestSize.Level1)
74 {
75 uint32_t uid = 0;
76 uint8_t allow = 0;
77 uint8_t isBroker = 0;
78 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
79 EXPECT_EQ(ret, NETMANAGER_ERROR);
80 }
81
82 /**
83 * @tc.name: SetInternetPermission002
84 * @tc.desc: Test ConnManager SetInternetPermission.
85 * @tc.type: FUNC
86 */
87 HWTEST_F(ConnManagerTest, SetInternetPermission002, TestSize.Level1)
88 {
89 uint32_t uid = 0;
90 uint8_t allow = 0;
91 uint8_t isBroker = 0;
92 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
93 EXPECT_EQ(ret, NETMANAGER_ERROR);
94 }
95
96 /**
97 * @tc.name: CreatePhysicalNetworkTest001
98 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
99 * @tc.type: FUNC
100 */
101 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest001, TestSize.Level1)
102 {
103 int32_t ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
104 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
105 }
106
107 /**
108 * @tc.name: CreatePhysicalNetworkTest002
109 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest002, TestSize.Level1)
113 {
114 int32_t ret = instance_->ReinitRoute();
115 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
116 ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
117 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
118 }
119
120 /**
121 * @tc.name: CreatePhysicalNetworkTest003
122 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest003, TestSize.Level1)
126 {
127 auto ret = instance_->CreatePhysicalNetwork(INTERNAL_NETID, PERMISSION_NONE);
128 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
129 }
130
131 /**
132 * @tc.name: CreateVirtualNetwork001
133 * @tc.desc: Test ConnManager CreateVirtualNetwork.
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ConnManagerTest, CreateVirtualNetwork001, TestSize.Level1)
137 {
138 uint16_t netId = 1;
139 bool hasDns = true;
140 int32_t ret = instance_->CreateVirtualNetwork(netId, hasDns);
141 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
142 }
143
144 /**
145 * @tc.name: DestroyNetworkTest001
146 * @tc.desc: Test ConnManager DestroyNetwork.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(ConnManagerTest, DestroyNetworkTest001, TestSize.Level1)
150 {
151 auto ret = instance_->DestroyNetwork(LOCAL_NET_ID);
152 EXPECT_EQ(ret, NETMANAGER_ERROR);
153 }
154
155 /**
156 * @tc.name: DestroyNetworkTest002
157 * @tc.desc: Test ConnManager DestroyNetwork.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(ConnManagerTest, DestroyNetworkTest002, TestSize.Level1)
161 {
162 int32_t ret = instance_->DestroyNetwork(NETID);
163 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
164 ret = instance_->DestroyNetwork(NETID);
165 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
166 }
167
168 /**
169 * @tc.name: DestroyNetworkTest003
170 * @tc.desc: Test ConnManager DestroyNetwork.
171 * @tc.type: FUNC
172 */
173 HWTEST_F(ConnManagerTest, DestroyNetworkTest003, TestSize.Level1)
174 {
175 int32_t netId = 100;
176 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
177 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
178
179 ret = instance_->DestroyNetwork(netId);
180 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
181 }
182
183 /**
184 * @tc.name: SetDefaultNetworkTest001
185 * @tc.desc: Test ConnManager SetDefaultNetwork.
186 * @tc.type: FUNC
187 */
188 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest001, TestSize.Level1)
189 {
190 int32_t ret = instance_->SetDefaultNetwork(NETID);
191 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
192 ret = instance_->SetDefaultNetwork(NETID);
193 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
194 }
195
196 /**
197 * @tc.name: SetDefaultNetworkTest002
198 * @tc.desc: Test ConnManager SetDefaultNetwork.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest002, TestSize.Level1)
202 {
203 int32_t ret = instance_->SetDefaultNetwork(0);
204 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
205 ret = instance_->SetDefaultNetwork(0);
206 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
207 ret = instance_->SetDefaultNetwork(NETID);
208 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
209 }
210
211 /**
212 * @tc.name: ClearDefaultNetwork001
213 * @tc.desc: Test ConnManager ClearDefaultNetwork.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(ConnManagerTest, ClearDefaultNetwork001, TestSize.Level1)
217 {
218 int32_t ret = instance_->ClearDefaultNetwork();
219 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
220 ret = instance_->ClearDefaultNetwork();
221 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
222 }
223
224 /**
225 * @tc.name: GetDefaultNetworkTest001
226 * @tc.desc: Test ConnManager GetDefaultNetwork.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(ConnManagerTest, GetDefaultNetworkTest001, TestSize.Level1)
230 {
231 int32_t ret = instance_->SetDefaultNetwork(NETID);
232 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
233 ret = instance_->GetDefaultNetwork();
234 EXPECT_EQ(ret, NETID);
235 }
236
237 /**
238 * @tc.name: AddInterfaceToNetworkTest001
239 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest001, TestSize.Level1)
243 {
244 std::string iface = INTERFACENAME;
245 int32_t ret = instance_->AddInterfaceToNetwork(NETID, iface, BEARER_DEFAULT);
246 EXPECT_NE(ret, 0);
247
248 iface = INTERNAL_INTERFACENAME;
249 ret = instance_->AddInterfaceToNetwork(INTERNAL_NETID, iface, BEARER_DEFAULT);
250 EXPECT_NE(ret, 0);
251 }
252
253 /**
254 * @tc.name: AddInterfaceToNetworkTest002
255 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest002, TestSize.Level1)
259 {
260 std::string testInterfaceName = "testName";
261 int32_t ret = instance_->AddInterfaceToNetwork(NETID, testInterfaceName, BEARER_DEFAULT);
262 EXPECT_NE(ret, 0);
263
264 ret = instance_->AddInterfaceToNetwork(INTERNAL_NETID, testInterfaceName, BEARER_DEFAULT);
265 EXPECT_NE(ret, 0);
266 }
267
268 /**
269 * @tc.name: RemoveInterfaceFromNetworkTest001
270 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest001, TestSize.Level1)
274 {
275 std::string iface = INTERFACENAME;
276 int32_t ret = instance_->RemoveInterfaceFromNetwork(NETID, iface);
277 EXPECT_LE(ret, NETMANAGER_SUCCESS);
278
279 iface = INTERNAL_INTERFACENAME;
280 ret = instance_->RemoveInterfaceFromNetwork(INTERNAL_NETID, iface);
281 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
282 }
283
284 /**
285 * @tc.name: RemoveInterfaceFromNetworkTest002
286 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest002, TestSize.Level1)
290 {
291 std::string testInterfaceName = "testName";
292 auto ret = instance_->RemoveInterfaceFromNetwork(NETID, testInterfaceName);
293 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
294
295 ret = instance_->RemoveInterfaceFromNetwork(INTERNAL_NETID, testInterfaceName);
296 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
297 }
298
299 /**
300 * @tc.name: AddRouteTest001
301 * @tc.desc: Test ConnManager AddRoute.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(ConnManagerTest, AddRouteTest001, TestSize.Level1)
305 {
306 bool flag = false;
307 int32_t ret = instance_->AddRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222", flag);
308 EXPECT_LE(ret, 0);
309 ret = instance_->AddRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0", flag);
310 EXPECT_LE(ret, 0);
311 }
312
313 /**
314 * @tc.name: RemoveRouteTest001
315 * @tc.desc: Test ConnManager AddRoute.
316 * @tc.type: FUNC
317 */
318 HWTEST_F(ConnManagerTest, RemoveRouteTest001, TestSize.Level1)
319 {
320 int32_t ret = instance_->RemoveRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
321 EXPECT_LE(ret, 0);
322 ret = instance_->RemoveRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
323 EXPECT_LE(ret, 0);
324 }
325
326 /**
327 * @tc.name: UpdateRouteTest001
328 * @tc.desc: Test ConnManager AddRoute.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(ConnManagerTest, UpdateRouteTest001, TestSize.Level1)
332 {
333 int32_t ret = instance_->UpdateRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
334 EXPECT_LE(ret, 0);
335 ret = instance_->UpdateRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
336 EXPECT_LE(ret, 0);
337 }
338
339 /**
340 * @tc.name: UpdateRouteTest002
341 * @tc.desc: Test ConnManager AddRoute.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(ConnManagerTest, UpdateRouteTest002, TestSize.Level1)
345 {
346 int32_t netId = 99;
347 int32_t ret = instance_->UpdateRoute(netId, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
348 EXPECT_EQ(ret, ERROR_CODE);
349 }
350
351 /**
352 * @tc.name: SetPermissionForNetwork001
353 * @tc.desc: Test ConnManager SetPermissionForNetwork.
354 * @tc.type: FUNC
355 */
356 HWTEST_F(ConnManagerTest, SetPermissionForNetwork001, TestSize.Level1)
357 {
358 int32_t netId = 99;
359 int32_t ret = instance_->SetPermissionForNetwork(netId, NetworkPermission::PERMISSION_NETWORK);
360 EXPECT_EQ(ret, NETMANAGER_ERROR);
361 }
362
363 /**
364 * @tc.name: AddUidsToNetwork001
365 * @tc.desc: Test ConnManager AddUidsToNetwork.
366 * @tc.type: FUNC
367 */
368 HWTEST_F(ConnManagerTest, AddUidsToNetwork001, TestSize.Level1)
369 {
370 int32_t netId = 99;
371 const std::vector<NetManagerStandard::UidRange> uidRanges;
372 int32_t ret = instance_->AddUidsToNetwork(netId, uidRanges);
373 EXPECT_EQ(ret, NETMANAGER_ERROR);
374
375 netId = 1;
376 ret = instance_->AddUidsToNetwork(netId, uidRanges);
377 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
378 }
379
380 /**
381 * @tc.name: RemoveUidsFromNetwork001
382 * @tc.desc: Test ConnManager RemoveUidsFromNetwork.
383 * @tc.type: FUNC
384 */
385 HWTEST_F(ConnManagerTest, RemoveUidsFromNetwork001, TestSize.Level1)
386 {
387 int32_t netId = 99;
388 const std::vector<NetManagerStandard::UidRange> uidRanges;
389 int32_t ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
390 EXPECT_EQ(ret, NETMANAGER_ERROR);
391
392 netId = 1;
393 ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
394 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
395 }
396
397 /**
398 * @tc.name: GetFwmarkForNetworkTest001
399 * @tc.desc: Test ConnManager GetFwmarkForNetwork.
400 * @tc.type: FUNC
401 */
402 HWTEST_F(ConnManagerTest, GetFwmarkForNetworkTest001, TestSize.Level1)
403 {
404 int32_t ret = instance_->GetFwmarkForNetwork(NETID);
405 EXPECT_LE(ret, 0);
406 std::string info;
407 instance_->GetDumpInfos(info);
408 ASSERT_FALSE(info.empty());
409 }
410
411 /**
412 * @tc.name: ConnManagerBranchTest001
413 * @tc.desc: Test ConnManager Branch.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(ConnManagerTest, ConnManagerBranchTest001, TestSize.Level1)
417 {
418 std::string testInterfaceName = "testName";
419 int32_t ret = instance_->GetNetworkForInterface(100, testInterfaceName);
420 EXPECT_EQ(ret, INVALID_VALUE);
421
422 RouteManager::TableType type = instance_->GetTableType(LOCAL_NET_ID);
423 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
424
425 type = instance_->GetTableType(LOCAL_NET_ID);
426 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
427
428 int32_t netId = 100;
429 type = instance_->GetTableType(netId);
430 EXPECT_EQ(type, RouteManager::TableType::INTERFACE);
431
432 auto result = instance_->FindVirtualNetwork(NETID);
433 EXPECT_EQ(result, nullptr);
434
435 result = instance_->FindVirtualNetwork(netId);
436 EXPECT_EQ(result, nullptr);
437
438 netId = 99;
439 result = instance_->FindVirtualNetwork(netId);
440 EXPECT_EQ(result, nullptr);
441 }
442
443 /**
444 * @tc.name: SetNetworkAccessPolicy001
445 * @tc.desc: Test ConnManager SetNetworkAccessPolicy.
446 * @tc.type: FUNC
447 */
448 HWTEST_F(ConnManagerTest, SetNetworkAccessPolicy001, TestSize.Level1)
449 {
450 uint32_t uid = 0;
451 NetworkAccessPolicy netAccessPolicy;
452 netAccessPolicy.wifiAllow = false;
453 netAccessPolicy.cellularAllow = false;
454 bool reconfirmFlag = true;
455 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
456 EXPECT_NE(ret, NETMANAGER_SUCCESS);
457 }
458
459 /**
460 * @tc.name: DeleteNetworkAccessPolicy001
461 * @tc.desc: Test ConnManager DeleteNetworkAccessPolicy.
462 * @tc.type: FUNC
463 */
464 HWTEST_F(ConnManagerTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
465 {
466 uint32_t uid = 0;
467 int32_t ret = instance_->DeleteNetworkAccessPolicy(uid);
468 EXPECT_NE(ret, NETMANAGER_SUCCESS);
469 }
470
471 /**
472 * @tc.name: NotifyNetBearerTypeChange001
473 * @tc.desc: Test ConnManager NotifyNetBearerTypeChange.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(ConnManagerTest, NotifyNetBearerTypeChange001, TestSize.Level1)
477 {
478 std::set<NetManagerStandard::NetBearType> bearTypes;
479
480 int32_t ret = instance_->NotifyNetBearerTypeChange(bearTypes);
481 EXPECT_EQ(ret, NETMANAGER_ERROR);
482 }
483
484 /**
485 * @tc.name: SetInternetPermission003
486 * @tc.desc: Test ConnManager SetInternetPermission.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(ConnManagerTest, SetInternetPermission003, TestSize.Level1)
490 {
491 uint32_t uid = 0;
492 uint8_t allow = 1;
493 uint8_t isBroker = 0;
494 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
495 EXPECT_EQ(ret, NETMANAGER_ERROR);
496
497 uid = 1;
498 ret = instance_->SetInternetPermission(uid, allow, isBroker);
499 EXPECT_EQ(ret, NETMANAGER_ERROR);
500
501 isBroker = 1;
502 ret = instance_->SetInternetPermission(uid, allow, isBroker);
503 EXPECT_EQ(ret, NETMANAGER_ERROR);
504 }
505
506 /**
507 * @tc.name: DestroyNetworkTest004
508 * @tc.desc: Test ConnManager DestroyNetwork.
509 * @tc.type: FUNC
510 */
511 HWTEST_F(ConnManagerTest, DestroyNetworkTest004, TestSize.Level1)
512 {
513 int32_t netId = 1;
514 instance_->defaultNetId_ = netId;
515 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
516 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
517 ret = instance_->DestroyNetwork(netId);
518 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
519 }
520
521 /**
522 * @tc.name: DestroyNetworkTest005
523 * @tc.desc: Test ConnManager DestroyNetwork.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(ConnManagerTest, DestroyNetworkTest005, TestSize.Level1)
527 {
528 int32_t netId = 1;
529 instance_->defaultNetId_ = netId;
530 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
531 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
532 ret = instance_->DestroyNetwork(netId);
533 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
534 }
535
536 /**
537 * @tc.name: SetDefaultNetworkTest003
538 * @tc.desc: Test ConnManager SetDefaultNetwork.
539 * @tc.type: FUNC
540 */
541 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest003, TestSize.Level1)
542 {
543 int32_t netId = 1;
544 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
545 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
546 ret = instance_->SetDefaultNetwork(netId);
547 EXPECT_EQ(ret, NETMANAGER_ERROR);
548 }
549
550 /**
551 * @tc.name: SetDefaultNetworkTest004
552 * @tc.desc: Test ConnManager SetDefaultNetwork.
553 * @tc.type: FUNC
554 */
555 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest004, TestSize.Level1)
556 {
557 int32_t netId = 1;
558 instance_->defaultNetId_ = 0;
559 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
560 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
561 ret = instance_->SetDefaultNetwork(netId);
562 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
563
564 instance_->defaultNetId_ = 2; // defaultNetId_ = 2
565 ret = instance_->CreateVirtualNetwork(instance_->defaultNetId_, true);
566 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
567 ret = instance_->SetDefaultNetwork(netId);
568 EXPECT_EQ(ret, NETMANAGER_ERROR);
569
570 ret = instance_->CreatePhysicalNetwork(instance_->defaultNetId_, PERMISSION_NONE);
571 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
572 ret = instance_->SetDefaultNetwork(netId);
573 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
574 }
575
576 /**
577 * @tc.name: ClearDefaultNetworkTest001
578 * @tc.desc: Test ConnManager SetDefaultNetwork.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(ConnManagerTest, ClearDefaultNetworkTest001, TestSize.Level1)
582 {
583 instance_->defaultNetId_ = 1;
584 int32_t ret = instance_->CreateVirtualNetwork(instance_->defaultNetId_, true);
585 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
586 ret = instance_->ClearDefaultNetwork();
587 EXPECT_EQ(ret, NETMANAGER_ERROR);
588 }
589
590 /**
591 * @tc.name: ClearDefaultNetworkTest002
592 * @tc.desc: Test ConnManager SetDefaultNetwork.
593 * @tc.type: FUNC
594 */
595 HWTEST_F(ConnManagerTest, ClearDefaultNetworkTest002, TestSize.Level1)
596 {
597 instance_->defaultNetId_ = 1;
598 int32_t ret = instance_->CreatePhysicalNetwork(instance_->defaultNetId_, PERMISSION_NONE);
599 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
600 ret = instance_->ClearDefaultNetwork();
601 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
602 }
603
604 /**
605 * @tc.name: AddInterfaceToNetworkTest003
606 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
607 * @tc.type: FUNC
608 */
609 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest003, TestSize.Level1)
610 {
611 int32_t netId = 1;
612 std::string testInterfaceName = "rmnet0";
613 NetManagerStandard::NetBearType netBearerType = BEARER_CELLULAR;
614 int32_t ret = instance_->AddInterfaceToNetwork(INTERNAL_NETID, testInterfaceName, netBearerType);
615 EXPECT_NE(ret, NETMANAGER_SUCCESS);
616 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
617 EXPECT_EQ(ret, NETMANAGER_ERROR);
618 }
619
620 /**
621 * @tc.name: AddInterfaceToNetworkTest004
622 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
623 * @tc.type: FUNC
624 */
625 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest004, TestSize.Level1)
626 {
627 int32_t netId = 1;
628 std::string testInterfaceName = "testName";
629 NetManagerStandard::NetBearType netBearerType = BEARER_DEFAULT;
630
631 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
632 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
633 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
634 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
635
636 ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
637 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
638 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
639 EXPECT_NE(ret, NETMANAGER_SUCCESS);
640
641 netBearerType = BEARER_WIFI;
642 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
643 EXPECT_NE(ret, NETMANAGER_SUCCESS);
644
645 netBearerType = BEARER_CELLULAR;
646 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
647 EXPECT_NE(ret, NETMANAGER_SUCCESS);
648 }
649
650 /**
651 * @tc.name: ConnManagerBranchTest002
652 * @tc.desc: Test ConnManager Branch.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(ConnManagerTest, ConnManagerBranchTest002, TestSize.Level1)
656 {
657 int32_t netId = 1;
658 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
659 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
660 RouteManager::TableType type = instance_->GetTableType(netId);
661 EXPECT_EQ(type, RouteManager::TableType::VPN_NETWORK);
662
663 netId = INTERNAL_NETID;
664 type = instance_->GetTableType(netId);
665 EXPECT_EQ(type, RouteManager::TableType::INTERNAL_DEFAULT);
666 }
667
668 /**
669 * @tc.name: FindVirtualNetworkTest001
670 * @tc.desc: Test ConnManager Branch.
671 * @tc.type: FUNC
672 */
673 HWTEST_F(ConnManagerTest, FindVirtualNetworkTest001, TestSize.Level1)
674 {
675 int32_t netId = 1;
676 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
677 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
678 std::shared_ptr<NetsysNetwork> netsysNetworkPtr = instance_->FindVirtualNetwork(netId);
679 EXPECT_EQ(netsysNetworkPtr, nullptr);
680 }
681
682 /**
683 * @tc.name: SetNetworkAccessPolicyTest002
684 * @tc.desc: Test ConnManager SetNetworkAccessPolicy.
685 * @tc.type: FUNC
686 */
687 HWTEST_F(ConnManagerTest, SetNetworkAccessPolicyTest002, TestSize.Level1)
688 {
689 uint32_t uid = 0;
690 NetworkAccessPolicy netAccessPolicy;
691 netAccessPolicy.wifiAllow = false;
692 netAccessPolicy.cellularAllow = false;
693 bool reconfirmFlag = true;
694 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
695 EXPECT_EQ(ret, NETMANAGER_ERROR);
696 }
697 } // namespace NetsysNative
698 } // namespace OHOS
699