1 /*
2 * Copyright (c) 2022-2023 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_EQ(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_EQ(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 int32_t ret = instance_->AddRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
307 EXPECT_LE(ret, 0);
308 ret = instance_->AddRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
309 EXPECT_LE(ret, 0);
310 }
311
312 /**
313 * @tc.name: RemoveRouteTest001
314 * @tc.desc: Test ConnManager AddRoute.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(ConnManagerTest, RemoveRouteTest001, TestSize.Level1)
318 {
319 int32_t ret = instance_->RemoveRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
320 EXPECT_LE(ret, 0);
321 ret = instance_->RemoveRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
322 EXPECT_LE(ret, 0);
323 }
324
325 /**
326 * @tc.name: UpdateRouteTest001
327 * @tc.desc: Test ConnManager AddRoute.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(ConnManagerTest, UpdateRouteTest001, TestSize.Level1)
331 {
332 int32_t ret = instance_->UpdateRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
333 EXPECT_LE(ret, 0);
334 ret = instance_->UpdateRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
335 EXPECT_LE(ret, 0);
336 }
337
338 /**
339 * @tc.name: UpdateRouteTest002
340 * @tc.desc: Test ConnManager AddRoute.
341 * @tc.type: FUNC
342 */
343 HWTEST_F(ConnManagerTest, UpdateRouteTest002, TestSize.Level1)
344 {
345 int32_t netId = 99;
346 int32_t ret = instance_->UpdateRoute(netId, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
347 EXPECT_EQ(ret, ERROR_CODE);
348 }
349
350 /**
351 * @tc.name: SetPermissionForNetwork001
352 * @tc.desc: Test ConnManager SetPermissionForNetwork.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(ConnManagerTest, SetPermissionForNetwork001, TestSize.Level1)
356 {
357 int32_t netId = 99;
358 int32_t ret = instance_->SetPermissionForNetwork(netId, NetworkPermission::PERMISSION_NETWORK);
359 EXPECT_EQ(ret, NETMANAGER_ERROR);
360 }
361
362 /**
363 * @tc.name: AddUidsToNetwork001
364 * @tc.desc: Test ConnManager AddUidsToNetwork.
365 * @tc.type: FUNC
366 */
367 HWTEST_F(ConnManagerTest, AddUidsToNetwork001, TestSize.Level1)
368 {
369 int32_t netId = 99;
370 const std::vector<NetManagerStandard::UidRange> uidRanges;
371 int32_t ret = instance_->AddUidsToNetwork(netId, uidRanges);
372 EXPECT_EQ(ret, NETMANAGER_ERROR);
373
374 netId = 1;
375 ret = instance_->AddUidsToNetwork(netId, uidRanges);
376 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
377 }
378
379 /**
380 * @tc.name: RemoveUidsFromNetwork001
381 * @tc.desc: Test ConnManager RemoveUidsFromNetwork.
382 * @tc.type: FUNC
383 */
384 HWTEST_F(ConnManagerTest, RemoveUidsFromNetwork001, TestSize.Level1)
385 {
386 int32_t netId = 99;
387 const std::vector<NetManagerStandard::UidRange> uidRanges;
388 int32_t ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
389 EXPECT_EQ(ret, NETMANAGER_ERROR);
390
391 netId = 1;
392 ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
393 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
394 }
395
396 /**
397 * @tc.name: GetFwmarkForNetworkTest001
398 * @tc.desc: Test ConnManager GetFwmarkForNetwork.
399 * @tc.type: FUNC
400 */
401 HWTEST_F(ConnManagerTest, GetFwmarkForNetworkTest001, TestSize.Level1)
402 {
403 int32_t ret = instance_->GetFwmarkForNetwork(NETID);
404 EXPECT_LE(ret, 0);
405 std::string info;
406 instance_->GetDumpInfos(info);
407 ASSERT_FALSE(info.empty());
408 }
409
410 /**
411 * @tc.name: ConnManagerBranchTest001
412 * @tc.desc: Test ConnManager Branch.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(ConnManagerTest, ConnManagerBranchTest001, TestSize.Level1)
416 {
417 std::string testInterfaceName = "testName";
418 int32_t ret = instance_->GetNetworkForInterface(100, testInterfaceName);
419 EXPECT_EQ(ret, INVALID_VALUE);
420
421 RouteManager::TableType type = instance_->GetTableType(LOCAL_NET_ID);
422 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
423
424 type = instance_->GetTableType(LOCAL_NET_ID);
425 EXPECT_EQ(type, RouteManager::TableType::LOCAL_NETWORK);
426
427 int32_t netId = 100;
428 type = instance_->GetTableType(netId);
429 EXPECT_EQ(type, RouteManager::TableType::INTERFACE);
430
431 auto result = instance_->FindVirtualNetwork(NETID);
432 EXPECT_EQ(result, nullptr);
433
434 result = instance_->FindVirtualNetwork(netId);
435 EXPECT_EQ(result, nullptr);
436
437 netId = 99;
438 result = instance_->FindVirtualNetwork(netId);
439 EXPECT_EQ(result, nullptr);
440 }
441
442 /**
443 * @tc.name: SetNetworkAccessPolicy001
444 * @tc.desc: Test ConnManager SetNetworkAccessPolicy.
445 * @tc.type: FUNC
446 */
447 HWTEST_F(ConnManagerTest, SetNetworkAccessPolicy001, TestSize.Level1)
448 {
449 uint32_t uid = 0;
450 NetworkAccessPolicy netAccessPolicy;
451 netAccessPolicy.wifiAllow = false;
452 netAccessPolicy.cellularAllow = false;
453 bool reconfirmFlag = true;
454 bool isBroker = false;
455 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag, isBroker);
456 EXPECT_EQ(ret, NETMANAGER_ERROR);
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_EQ(ret, NETMANAGER_ERROR);
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 } // namespace NetsysNative
484 } // namespace OHOS
485