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 }
251
252 /**
253 * @tc.name: AddInterfaceToNetworkTest002
254 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest002, TestSize.Level1)
258 {
259 std::string testInterfaceName = "testName";
260 int32_t ret = instance_->AddInterfaceToNetwork(NETID, testInterfaceName, BEARER_DEFAULT);
261 EXPECT_NE(ret, 0);
262
263 ret = instance_->AddInterfaceToNetwork(INTERNAL_NETID, testInterfaceName, BEARER_DEFAULT);
264 }
265
266 /**
267 * @tc.name: RemoveInterfaceFromNetworkTest001
268 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest001, TestSize.Level1)
272 {
273 std::string iface = INTERFACENAME;
274 int32_t ret = instance_->RemoveInterfaceFromNetwork(NETID, iface);
275 EXPECT_LE(ret, NETMANAGER_SUCCESS);
276
277 iface = INTERNAL_INTERFACENAME;
278 ret = instance_->RemoveInterfaceFromNetwork(INTERNAL_NETID, iface);
279 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
280 }
281
282 /**
283 * @tc.name: RemoveInterfaceFromNetworkTest002
284 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
285 * @tc.type: FUNC
286 */
287 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest002, TestSize.Level1)
288 {
289 std::string testInterfaceName = "testName";
290 auto ret = instance_->RemoveInterfaceFromNetwork(NETID, testInterfaceName);
291 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
292
293 ret = instance_->RemoveInterfaceFromNetwork(INTERNAL_NETID, testInterfaceName);
294 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
295 }
296
297 /**
298 * @tc.name: AddRouteTest001
299 * @tc.desc: Test ConnManager AddRoute.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(ConnManagerTest, AddRouteTest001, TestSize.Level1)
303 {
304 bool flag = false;
305 NetworkRouteInfo networkRouteInfo;
306 networkRouteInfo.ifName = INTERFACENAME;
307 networkRouteInfo.destination = "0.0.0.0/0";
308 networkRouteInfo.nextHop = "192.168.113.222";
309 networkRouteInfo.isExcludedRoute = false;
310 int32_t ret = instance_->AddRoute(NETID, networkRouteInfo, flag);
311 EXPECT_LE(ret, 0);
312 networkRouteInfo.destination = "192.168.113.0/24";
313 networkRouteInfo.nextHop = "0.0.0.0";
314 ret = instance_->AddRoute(NETID, networkRouteInfo, flag);
315 EXPECT_LE(ret, 0);
316 }
317
318 /**
319 * @tc.name: RemoveRouteTest001
320 * @tc.desc: Test ConnManager AddRoute.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(ConnManagerTest, RemoveRouteTest001, TestSize.Level1)
324 {
325 int32_t ret = instance_->RemoveRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
326 EXPECT_LE(ret, 0);
327 ret = instance_->RemoveRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
328 EXPECT_LE(ret, 0);
329 }
330
331 /**
332 * @tc.name: UpdateRouteTest001
333 * @tc.desc: Test ConnManager AddRoute.
334 * @tc.type: FUNC
335 */
336 HWTEST_F(ConnManagerTest, UpdateRouteTest001, TestSize.Level1)
337 {
338 int32_t ret = instance_->UpdateRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
339 EXPECT_LE(ret, 0);
340 ret = instance_->UpdateRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
341 EXPECT_LE(ret, 0);
342 }
343
344 /**
345 * @tc.name: UpdateRouteTest002
346 * @tc.desc: Test ConnManager AddRoute.
347 * @tc.type: FUNC
348 */
349 HWTEST_F(ConnManagerTest, UpdateRouteTest002, TestSize.Level1)
350 {
351 int32_t netId = 99;
352 int32_t ret = instance_->UpdateRoute(netId, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
353 EXPECT_EQ(ret, ERROR_CODE);
354 }
355
356 /**
357 * @tc.name: SetPermissionForNetwork001
358 * @tc.desc: Test ConnManager SetPermissionForNetwork.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(ConnManagerTest, SetPermissionForNetwork001, TestSize.Level1)
362 {
363 int32_t netId = 99;
364 int32_t ret = instance_->SetPermissionForNetwork(netId, NetworkPermission::PERMISSION_NETWORK);
365 EXPECT_EQ(ret, NETMANAGER_ERROR);
366 }
367
368 /**
369 * @tc.name: AddUidsToNetwork001
370 * @tc.desc: Test ConnManager AddUidsToNetwork.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(ConnManagerTest, AddUidsToNetwork001, TestSize.Level1)
374 {
375 int32_t netId = 99;
376 const std::vector<NetManagerStandard::UidRange> uidRanges;
377 int32_t ret = instance_->AddUidsToNetwork(netId, uidRanges);
378 EXPECT_EQ(ret, NETMANAGER_ERROR);
379
380 netId = 1;
381 ret = instance_->AddUidsToNetwork(netId, uidRanges);
382 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
383 }
384
385 /**
386 * @tc.name: RemoveUidsFromNetwork001
387 * @tc.desc: Test ConnManager RemoveUidsFromNetwork.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(ConnManagerTest, RemoveUidsFromNetwork001, TestSize.Level1)
391 {
392 int32_t netId = 99;
393 const std::vector<NetManagerStandard::UidRange> uidRanges;
394 int32_t ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
395 EXPECT_EQ(ret, NETMANAGER_ERROR);
396
397 netId = 1;
398 ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
399 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
400 }
401
402 /**
403 * @tc.name: GetFwmarkForNetworkTest001
404 * @tc.desc: Test ConnManager GetFwmarkForNetwork.
405 * @tc.type: FUNC
406 */
407 HWTEST_F(ConnManagerTest, GetFwmarkForNetworkTest001, TestSize.Level1)
408 {
409 int32_t ret = instance_->GetFwmarkForNetwork(NETID);
410 EXPECT_LE(ret, 0);
411 std::string info;
412 instance_->GetDumpInfos(info);
413 ASSERT_FALSE(info.empty());
414 }
415
416 /**
417 * @tc.name: ConnManagerBranchTest001
418 * @tc.desc: Test ConnManager Branch.
419 * @tc.type: FUNC
420 */
421 HWTEST_F(ConnManagerTest, ConnManagerBranchTest001, TestSize.Level1)
422 {
423 std::string testInterfaceName = "testName";
424 int32_t ret = instance_->GetNetworkForInterface(100, testInterfaceName);
425 EXPECT_EQ(ret, INVALID_VALUE);
426
427 RouteManager::TableType type = instance_->GetTableType(LOCAL_NET_ID);
428 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
429
430 type = instance_->GetTableType(LOCAL_NET_ID);
431 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
432
433 int32_t netId = 100;
434 type = instance_->GetTableType(netId);
435 EXPECT_EQ(type, RouteManager::TableType::INTERFACE);
436
437 auto result = instance_->FindVirtualNetwork(NETID);
438 EXPECT_EQ(result, nullptr);
439
440 result = instance_->FindVirtualNetwork(netId);
441 EXPECT_EQ(result, nullptr);
442
443 netId = 99;
444 result = instance_->FindVirtualNetwork(netId);
445 EXPECT_EQ(result, nullptr);
446 }
447
448 /**
449 * @tc.name: SetNetworkAccessPolicy001
450 * @tc.desc: Test ConnManager SetNetworkAccessPolicy.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(ConnManagerTest, SetNetworkAccessPolicy001, TestSize.Level1)
454 {
455 uint32_t uid = 0;
456 NetworkAccessPolicy netAccessPolicy;
457 netAccessPolicy.wifiAllow = false;
458 netAccessPolicy.cellularAllow = false;
459 bool reconfirmFlag = true;
460 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
461 EXPECT_NE(ret, NETMANAGER_SUCCESS);
462 }
463
464 /**
465 * @tc.name: DeleteNetworkAccessPolicy001
466 * @tc.desc: Test ConnManager DeleteNetworkAccessPolicy.
467 * @tc.type: FUNC
468 */
469 HWTEST_F(ConnManagerTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
470 {
471 uint32_t uid = 0;
472 int32_t ret = instance_->DeleteNetworkAccessPolicy(uid);
473 EXPECT_NE(ret, NETMANAGER_SUCCESS);
474 }
475
476 /**
477 * @tc.name: NotifyNetBearerTypeChange001
478 * @tc.desc: Test ConnManager NotifyNetBearerTypeChange.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(ConnManagerTest, NotifyNetBearerTypeChange001, TestSize.Level1)
482 {
483 std::set<NetManagerStandard::NetBearType> bearTypes;
484
485 int32_t ret = instance_->NotifyNetBearerTypeChange(bearTypes);
486 EXPECT_EQ(ret, NETMANAGER_ERROR);
487 }
488
489 /**
490 * @tc.name: SetInternetPermission003
491 * @tc.desc: Test ConnManager SetInternetPermission.
492 * @tc.type: FUNC
493 */
494 HWTEST_F(ConnManagerTest, SetInternetPermission003, TestSize.Level1)
495 {
496 uint32_t uid = 0;
497 uint8_t allow = 1;
498 uint8_t isBroker = 0;
499 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
500 EXPECT_EQ(ret, NETMANAGER_ERROR);
501
502 uid = 1;
503 ret = instance_->SetInternetPermission(uid, allow, isBroker);
504 EXPECT_EQ(ret, NETMANAGER_ERROR);
505
506 isBroker = 1;
507 ret = instance_->SetInternetPermission(uid, allow, isBroker);
508 }
509
510 /**
511 * @tc.name: DestroyNetworkTest004
512 * @tc.desc: Test ConnManager DestroyNetwork.
513 * @tc.type: FUNC
514 */
515 HWTEST_F(ConnManagerTest, DestroyNetworkTest004, TestSize.Level1)
516 {
517 int32_t netId = 1;
518 instance_->defaultNetId_ = netId;
519 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
520 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
521 ret = instance_->DestroyNetwork(netId);
522 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
523 }
524
525 /**
526 * @tc.name: DestroyNetworkTest005
527 * @tc.desc: Test ConnManager DestroyNetwork.
528 * @tc.type: FUNC
529 */
530 HWTEST_F(ConnManagerTest, DestroyNetworkTest005, TestSize.Level1)
531 {
532 int32_t netId = 1;
533 instance_->defaultNetId_ = netId;
534 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
535 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
536 ret = instance_->DestroyNetwork(netId);
537 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
538 }
539
540 /**
541 * @tc.name: SetDefaultNetworkTest003
542 * @tc.desc: Test ConnManager SetDefaultNetwork.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest003, TestSize.Level1)
546 {
547 int32_t netId = 1;
548 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
549 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
550 ret = instance_->SetDefaultNetwork(netId);
551 EXPECT_EQ(ret, NETMANAGER_ERROR);
552 }
553
554 /**
555 * @tc.name: SetDefaultNetworkTest004
556 * @tc.desc: Test ConnManager SetDefaultNetwork.
557 * @tc.type: FUNC
558 */
559 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest004, TestSize.Level1)
560 {
561 int32_t netId = 1;
562 instance_->defaultNetId_ = 0;
563 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
564 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
565 ret = instance_->SetDefaultNetwork(netId);
566 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
567
568 instance_->defaultNetId_ = 2; // defaultNetId_ = 2
569 ret = instance_->CreateVirtualNetwork(instance_->defaultNetId_, true);
570 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
571 ret = instance_->SetDefaultNetwork(netId);
572 EXPECT_EQ(ret, NETMANAGER_ERROR);
573
574 ret = instance_->CreatePhysicalNetwork(instance_->defaultNetId_, PERMISSION_NONE);
575 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
576 ret = instance_->SetDefaultNetwork(netId);
577 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
578 }
579
580 /**
581 * @tc.name: ClearDefaultNetworkTest001
582 * @tc.desc: Test ConnManager SetDefaultNetwork.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(ConnManagerTest, ClearDefaultNetworkTest001, TestSize.Level1)
586 {
587 instance_->defaultNetId_ = 1;
588 int32_t ret = instance_->CreateVirtualNetwork(instance_->defaultNetId_, true);
589 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
590 ret = instance_->ClearDefaultNetwork();
591 EXPECT_EQ(ret, NETMANAGER_ERROR);
592 }
593
594 /**
595 * @tc.name: ClearDefaultNetworkTest002
596 * @tc.desc: Test ConnManager SetDefaultNetwork.
597 * @tc.type: FUNC
598 */
599 HWTEST_F(ConnManagerTest, ClearDefaultNetworkTest002, TestSize.Level1)
600 {
601 instance_->defaultNetId_ = 1;
602 int32_t ret = instance_->CreatePhysicalNetwork(instance_->defaultNetId_, PERMISSION_NONE);
603 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
604 ret = instance_->ClearDefaultNetwork();
605 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
606 }
607
608 /**
609 * @tc.name: AddInterfaceToNetworkTest003
610 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
611 * @tc.type: FUNC
612 */
613 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest003, TestSize.Level1)
614 {
615 int32_t netId = 1;
616 std::string testInterfaceName = "rmnet0";
617 NetManagerStandard::NetBearType netBearerType = BEARER_CELLULAR;
618 int32_t ret = instance_->AddInterfaceToNetwork(INTERNAL_NETID, testInterfaceName, netBearerType);
619 EXPECT_NE(ret, NETMANAGER_SUCCESS);
620 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
621 EXPECT_EQ(ret, NETMANAGER_ERROR);
622 }
623
624 /**
625 * @tc.name: AddInterfaceToNetworkTest004
626 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
627 * @tc.type: FUNC
628 */
629 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest004, TestSize.Level1)
630 {
631 int32_t netId = 1;
632 std::string testInterfaceName = "testName";
633 NetManagerStandard::NetBearType netBearerType = BEARER_DEFAULT;
634
635 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
636 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
637 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
638 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
639
640 ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
641 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
642 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
643 EXPECT_NE(ret, NETMANAGER_SUCCESS);
644
645 netBearerType = BEARER_WIFI;
646 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
647
648 netBearerType = BEARER_CELLULAR;
649 ret = instance_->AddInterfaceToNetwork(netId, testInterfaceName, netBearerType);
650 EXPECT_NE(ret, NETMANAGER_SUCCESS);
651 }
652
653 /**
654 * @tc.name: ConnManagerBranchTest002
655 * @tc.desc: Test ConnManager Branch.
656 * @tc.type: FUNC
657 */
658 HWTEST_F(ConnManagerTest, ConnManagerBranchTest002, TestSize.Level1)
659 {
660 int32_t netId = 1;
661 int32_t ret = instance_->CreateVirtualNetwork(netId, true);
662 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
663 RouteManager::TableType type = instance_->GetTableType(netId);
664 EXPECT_EQ(type, RouteManager::TableType::VPN_NETWORK);
665
666 netId = INTERNAL_NETID;
667 type = instance_->GetTableType(netId);
668 EXPECT_EQ(type, RouteManager::TableType::INTERNAL_DEFAULT);
669 }
670
671 /**
672 * @tc.name: FindVirtualNetworkTest001
673 * @tc.desc: Test ConnManager Branch.
674 * @tc.type: FUNC
675 */
676 HWTEST_F(ConnManagerTest, FindVirtualNetworkTest001, TestSize.Level1)
677 {
678 int32_t netId = 1;
679 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
680 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
681 std::shared_ptr<NetsysNetwork> netsysNetworkPtr = instance_->FindVirtualNetwork(netId);
682 EXPECT_EQ(netsysNetworkPtr, nullptr);
683 }
684
685 /**
686 * @tc.name: SetNetworkAccessPolicyTest002
687 * @tc.desc: Test ConnManager SetNetworkAccessPolicy.
688 * @tc.type: FUNC
689 */
690 HWTEST_F(ConnManagerTest, SetNetworkAccessPolicyTest002, TestSize.Level1)
691 {
692 uint32_t uid = 0;
693 NetworkAccessPolicy netAccessPolicy;
694 netAccessPolicy.wifiAllow = false;
695 netAccessPolicy.cellularAllow = false;
696 bool reconfirmFlag = true;
697 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
698 EXPECT_EQ(ret, NETMANAGER_ERROR);
699 }
700
701 /**
702 * @tc.name: DestroyNetworkTest006
703 * @tc.desc: Test ConnManager DestroyNetwork.
704 * @tc.type: FUNC
705 */
706 HWTEST_F(ConnManagerTest, DestroyNetworkTest006, TestSize.Level1)
707 {
708 ConnManager connmanager;
709 connmanager.defaultNetId_ = NETID;
710 int32_t ret = connmanager.DestroyNetwork(NETID);
711 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
712 ret = connmanager.DestroyNetwork(NETID);
713 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
714 }
715
716 /**
717 * @tc.name: NotifyNetBearerTypeChange002
718 * @tc.desc: Test ConnManager NotifyNetBearerTypeChange.
719 * @tc.type: FUNC
720 */
721 HWTEST_F(ConnManagerTest, NotifyNetBearerTypeChange002, TestSize.Level1)
722 {
723 std::set<NetManagerStandard::NetBearType> bearTypes;
724 bearTypes.insert(NetManagerStandard::NetBearType::BEARER_WIFI);
725
726 int32_t ret = instance_->NotifyNetBearerTypeChange(bearTypes);
727 EXPECT_NE(ret, NETMANAGER_SUCCESS);
728 }
729
730 /**
731 * @tc.name: NotifyNetBearerTypeChange003
732 * @tc.desc: Test ConnManager NotifyNetBearerTypeChange.
733 * @tc.type: FUNC
734 */
735 HWTEST_F(ConnManagerTest, NotifyNetBearerTypeChange003, TestSize.Level1)
736 {
737 std::set<NetManagerStandard::NetBearType> bearTypes;
738 bearTypes.insert(NetManagerStandard::NetBearType::BEARER_BLUETOOTH);
739
740 int32_t ret = instance_->NotifyNetBearerTypeChange(bearTypes);
741 EXPECT_NE(ret, NETMANAGER_SUCCESS);
742 }
743
744 HWTEST_F(ConnManagerTest, SetInternetPermission004, TestSize.Level1)
745 {
746 uint32_t uid = 1;
747 uint8_t allow = 0;
748 uint8_t isBroker = 0;
749 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
750 EXPECT_EQ(ret, NETMANAGER_ERROR);
751 isBroker = 1;
752 ret = instance_->SetInternetPermission(uid, allow, isBroker);
753 }
754
755 HWTEST_F(ConnManagerTest, GetInterfaceNameId001, TestSize.Level1)
756 {
757 NetManagerStandard::NetBearType netBearerType = BEARER_WIFI;
758 EXPECT_EQ(instance_->GetInterfaceNameId(netBearerType), NETWORK_BEARER_TYPE_WIFI);
759
760 netBearerType = BEARER_CELLULAR;
761 EXPECT_EQ(instance_->GetInterfaceNameId(netBearerType), NETWORK_BEARER_TYPE_CELLULAR);
762
763 netBearerType = BEARER_BLUETOOTH;
764 EXPECT_EQ(instance_->GetInterfaceNameId(netBearerType), NETWORK_BEARER_TYPE_INITIAL);
765 }
766 } // namespace NetsysNative
767 } // namespace OHOS
768