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 <gtest/gtest.h>
17 #include <chrono>
18 #include <thread>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24
25 #include "net_manager_constants.h"
26 #include "route_manager.h"
27
28 namespace OHOS {
29 namespace nmd {
30 namespace {
31 using namespace testing::ext;
32 using namespace OHOS::NetManagerStandard;
33 constexpr const char *TEST_SYS_VPN_CALL = "1";
34 constexpr const char *TEST_EXT_VPN_CALL = "0";
35 } // namespace
36
37 class RouteManagerExtTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void RouteManagerExtTest::SetUpTestCase() {}
46
TearDownTestCase()47 void RouteManagerExtTest::TearDownTestCase()
48 {
49 std::this_thread::sleep_for(std::chrono::seconds(1));
50 }
51
SetUp()52 void RouteManagerExtTest::SetUp() {}
53
TearDown()54 void RouteManagerExtTest::TearDown() {}
55
56 HWTEST_F(RouteManagerExtTest, AddInterfaceToVirtualNetwork003, TestSize.Level1)
57 {
58 RouteManager::interfaceToTable_.clear();
59 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
60 EXPECT_EQ(result, NETMANAGER_SUCCESS);
61
62 uint16_t testNetId = 154;
63 std::string testInterfaceName = "vpn";
64 auto ret = RouteManager::AddInterfaceToVirtualNetwork(testNetId, testInterfaceName);
65 EXPECT_EQ(ret, 0);
66 }
67
68 HWTEST_F(RouteManagerExtTest, RemoveInterfaceFromVirtualNetwork002, TestSize.Level1)
69 {
70 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
71 EXPECT_EQ(result, NETMANAGER_SUCCESS);
72
73 uint16_t testNetId = 154;
74 std::string testInterfaceName = "vpn";
75 auto ret = RouteManager::RemoveInterfaceFromVirtualNetwork(testNetId, testInterfaceName);
76 EXPECT_EQ(ret, 0);
77
78 testInterfaceName = "eth0";
79 ret = RouteManager::RemoveInterfaceFromVirtualNetwork(testNetId, testInterfaceName);
80 EXPECT_EQ(ret, 0);
81 }
82
83 HWTEST_F(RouteManagerExtTest, RemoveInterfaceFromVirtualNetwork003, TestSize.Level1)
84 {
85 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
86 EXPECT_EQ(result, NETMANAGER_SUCCESS);
87
88 uint16_t testNetId = 154;
89 std::string testInterfaceName = "vpn";
90 auto ret = RouteManager::RemoveInterfaceFromVirtualNetwork(testNetId, testInterfaceName);
91 EXPECT_EQ(ret, 0);
92 testInterfaceName = "eth0";
93 ret = RouteManager::RemoveInterfaceFromVirtualNetwork(testNetId, testInterfaceName);
94 EXPECT_EQ(ret, 0);
95 }
96
97 HWTEST_F(RouteManagerExtTest, AddUsersToVirtualNetwork002, TestSize.Level1)
98 {
99 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
100 EXPECT_EQ(result, NETMANAGER_SUCCESS);
101
102 uint16_t testNetId = 154;
103 std::string testInterfaceName = "testName1";
104 std::vector<NetManagerStandard::UidRange> uidRanges;
105 auto ret = RouteManager::AddUsersToVirtualNetwork(testNetId, testInterfaceName, uidRanges);
106 EXPECT_EQ(ret, 0);
107 }
108
109 HWTEST_F(RouteManagerExtTest, RemoveUsersFromVirtualNetwork002, TestSize.Level1)
110 {
111 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
112 EXPECT_EQ(result, NETMANAGER_SUCCESS);
113
114 uint16_t testNetId = 154;
115 std::string testInterfaceName = "testName1";
116 std::vector<NetManagerStandard::UidRange> uidRanges;
117 auto ret = RouteManager::RemoveUsersFromVirtualNetwork(testNetId, testInterfaceName, uidRanges);
118 EXPECT_EQ(ret, 0);
119 }
120
121 HWTEST_F(RouteManagerExtTest, UpdateVpnOutputToLocalRule001, TestSize.Level1)
122 {
123 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
124 EXPECT_EQ(result, NETMANAGER_SUCCESS);
125
126 std::string testInterfaceName = "testName1";
127 auto ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, true);
128 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
129 ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, false);
130 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
131
132 testInterfaceName = "vpn-tun";
133 ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, true);
134 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
135 testInterfaceName = "ppp";
136 ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, false);
137 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
138 }
139
140 HWTEST_F(RouteManagerExtTest, UpdateVpnOutputToLocalRule002, TestSize.Level1)
141 {
142 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
143 EXPECT_EQ(result, NETMANAGER_SUCCESS);
144
145 std::string testInterfaceName = "testName1";
146 auto ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, true);
147 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
148 ret = RouteManager::UpdateVpnOutputToLocalRule(testInterfaceName, false);
149 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
150 }
151
152 HWTEST_F(RouteManagerExtTest, UpdateVpnSystemPermissionRule001, TestSize.Level1)
153 {
154 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
155 EXPECT_EQ(result, NETMANAGER_SUCCESS);
156
157 uint16_t testNetId = 154;
158 uint32_t table = 106;
159 std::string testInterfaceName = "xfrm-vpn1";
160 auto ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, true, testInterfaceName);
161 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
162 ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, false, testInterfaceName);
163 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
164 testInterfaceName = "vpn-tun1";
165 ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, false, testInterfaceName);
166 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
167 }
168
169 HWTEST_F(RouteManagerExtTest, UpdateVpnSystemPermissionRule002, TestSize.Level1)
170 {
171 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
172 EXPECT_EQ(result, NETMANAGER_SUCCESS);
173
174 uint16_t testNetId = 154;
175 uint32_t table = 106;
176 std::string testInterfaceName = "xfrm-vpn1";
177 auto ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, true, testInterfaceName);
178 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
179 ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, false, testInterfaceName);
180 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
181 testInterfaceName = "vpn-tun1";
182 ret = RouteManager::UpdateVpnSystemPermissionRule(testNetId, table, false, testInterfaceName);
183 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
184 }
185
186 HWTEST_F(RouteManagerExtTest, UpdateExplicitNetworkRuleWithUid001, TestSize.Level1)
187 {
188 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
189 EXPECT_EQ(result, NETMANAGER_SUCCESS);
190
191 uint16_t testNetId = 154;
192 uint32_t table = 106;
193 std::string testInterfaceName = "xfrm-vpn1";
194 NetworkPermission permission = PERMISSION_NONE;
195 auto ret =
196 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, true, testInterfaceName);
197 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
198 ret =
199 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, false, testInterfaceName);
200 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
201 testInterfaceName = "vpn-tun1";
202 ret =
203 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, false, testInterfaceName);
204 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
205 }
206
207 HWTEST_F(RouteManagerExtTest, UpdateExplicitNetworkRuleWithUid002, TestSize.Level1)
208 {
209 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
210 EXPECT_EQ(result, NETMANAGER_SUCCESS);
211
212 uint16_t testNetId = 154;
213 uint32_t table = 106;
214 std::string testInterfaceName = "xfrm-vpn1";
215 NetworkPermission permission = PERMISSION_NONE;
216 auto ret =
217 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, true, testInterfaceName);
218 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
219 ret =
220 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, false, testInterfaceName);
221 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
222 testInterfaceName = "vpn-tun1";
223 ret =
224 RouteManager::UpdateExplicitNetworkRuleWithUid(testNetId, table, permission, 0, 0, false, testInterfaceName);
225 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
226 }
227
228 HWTEST_F(RouteManagerExtTest, UpdateOutputInterfaceRulesWithUid003, TestSize.Level1)
229 {
230 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
231 EXPECT_EQ(result, NETMANAGER_SUCCESS);
232
233 uint16_t testNetId = 154;
234 uint32_t table = 106;
235 std::string testInterfaceName = "xfrm-vpn1";
236 NetworkPermission permission = PERMISSION_NONE;
237 auto ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, true);
238 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
239 ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, false);
240 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
241 testInterfaceName = "vpn-tun";
242 ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, false);
243 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
244 }
245
246 HWTEST_F(RouteManagerExtTest, UpdateOutputInterfaceRulesWithUid004, TestSize.Level1)
247 {
248 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
249 EXPECT_EQ(result, NETMANAGER_SUCCESS);
250
251 uint16_t testNetId = 154;
252 uint32_t table = 106;
253 std::string testInterfaceName = "xfrm-vpn1";
254 NetworkPermission permission = PERMISSION_NONE;
255 auto ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, true);
256 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
257 ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, false);
258 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
259 testInterfaceName = "vpn-tun";
260 ret = RouteManager::UpdateOutputInterfaceRulesWithUid(testInterfaceName, table, permission, 0, 0, false);
261 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
262 }
263
264 HWTEST_F(RouteManagerExtTest, UpdateVirtualNetworkTest003, TestSize.Level1)
265 {
266 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
267 EXPECT_EQ(result, NETMANAGER_SUCCESS);
268
269 NetManagerStandard::UidRange uidRange{};
270 std::vector<NetManagerStandard::UidRange> uidRanges;
271 uidRanges.push_back(uidRange);
272 uint16_t testNetId = 0;
273 std::string testInterfaceName = "rmnet0";
274 bool add = true;
275 auto ret = RouteManager::UpdateVirtualNetwork(testNetId, testInterfaceName, uidRanges, add);
276 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
277 }
278
279 HWTEST_F(RouteManagerExtTest, UpdateVirtualNetworkTest004, TestSize.Level1)
280 {
281 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
282 EXPECT_EQ(result, NETMANAGER_SUCCESS);
283
284 NetManagerStandard::UidRange uidRange{};
285 std::vector<NetManagerStandard::UidRange> uidRanges;
286 uidRanges.push_back(uidRange);
287 uint16_t testNetId = 0;
288 std::string testInterfaceName = "xfrm-vpn1";
289 bool add = true;
290 auto ret = RouteManager::UpdateVirtualNetwork(testNetId, testInterfaceName, uidRanges, add);
291 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
292 }
293
294 HWTEST_F(RouteManagerExtTest, SetVpnCallMode001, TestSize.Level1)
295 {
296 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
297 EXPECT_EQ(result, NETMANAGER_SUCCESS);
298 }
299
300 HWTEST_F(RouteManagerExtTest, SetVpnCallMode002, TestSize.Level1)
301 {
302 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
303 EXPECT_EQ(result, NETMANAGER_SUCCESS);
304 }
305
306 HWTEST_F(RouteManagerExtTest, UpdateVpnRules001, TestSize.Level1)
307 {
308 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
309 EXPECT_EQ(result, NETMANAGER_SUCCESS);
310
311 const std::string ipAddr = "192.168.1.21";
312 std::vector<std::string> extMessages;
313 extMessages.emplace_back(ipAddr);
314 uint16_t netId = 103;
315 std::string interface = "xfrm-vpn1";
316 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
317 EXPECT_EQ(result, NETMANAGER_SUCCESS);
318 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, false);
319 EXPECT_EQ(result, NETMANAGER_SUCCESS);
320 }
321
322 HWTEST_F(RouteManagerExtTest, UpdateVpnRules002, TestSize.Level1)
323 {
324 int32_t result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
325 EXPECT_EQ(result, NETMANAGER_SUCCESS);
326
327 const std::string ipAddr = "192.168.1.21";
328 std::vector<std::string> extMessages;
329 extMessages.emplace_back(ipAddr);
330 uint16_t netId = 103;
331 std::string interface = "";
332 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
333 EXPECT_EQ(result, NETMANAGER_ERROR);
334 }
335
336 HWTEST_F(RouteManagerExtTest, UpdateVpnRules003, TestSize.Level1)
337 {
338 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
339 EXPECT_EQ(result, NETMANAGER_SUCCESS);
340
341 const std::string ipAddr = "192.168.1.21";
342 std::vector<std::string> extMessages;
343 extMessages.emplace_back(ipAddr);
344 uint16_t netId = 103;
345 std::string interface = "xfrm-vpn1";
346 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
347 EXPECT_TRUE(result <= 0);
348 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, false);
349 EXPECT_EQ(result, NETMANAGER_SUCCESS);
350 interface = "vpn-tun";
351 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
352 EXPECT_EQ(result, NETMANAGER_SUCCESS);
353 }
354
355 HWTEST_F(RouteManagerExtTest, UpdateVpnRules004, TestSize.Level1)
356 {
357 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
358 EXPECT_EQ(result, NETMANAGER_SUCCESS);
359
360 const std::string ipAddr = "192.168.1";
361 std::vector<std::string> extMessages;
362 extMessages.emplace_back(ipAddr);
363 uint16_t netId = 103;
364 std::string interface = "vpn-tun";
365 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
366 EXPECT_EQ(result, NETMANAGER_ERROR);
367 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, false);
368 EXPECT_EQ(result, NETMANAGER_ERROR);
369 interface = "";
370 result = RouteManager::UpdateVpnRules(netId, interface, extMessages, true);
371 EXPECT_EQ(result, NETMANAGER_ERROR);
372 }
373
374 HWTEST_F(RouteManagerExtTest, CheckSysVpnCall001, TestSize.Level1)
375 {
376 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
377 EXPECT_EQ(result, NETMANAGER_SUCCESS);
378
379 EXPECT_TRUE(RouteManager::CheckSysVpnCall());
380
381 result = RouteManager::SetVpnCallMode(TEST_EXT_VPN_CALL);
382 EXPECT_EQ(result, NETMANAGER_SUCCESS);
383
384 EXPECT_FALSE(RouteManager::CheckSysVpnCall());
385 }
386
387 HWTEST_F(RouteManagerExtTest, CheckTunVpnCall001, TestSize.Level1)
388 {
389 std::string infaceName = "eth0";
390 EXPECT_FALSE(RouteManager::CheckTunVpnCall(infaceName));
391
392 infaceName = "vpn-tun";
393 EXPECT_TRUE(RouteManager::CheckTunVpnCall(infaceName));
394
395 infaceName = "xfrm-vpn1";
396 EXPECT_FALSE(RouteManager::CheckTunVpnCall(infaceName));
397
398 infaceName = "";
399 EXPECT_FALSE(RouteManager::CheckTunVpnCall(infaceName));
400 }
401
402 HWTEST_F(RouteManagerExtTest, InitOutcomingPacketMark001, TestSize.Level1)
403 {
404 int32_t result = RouteManager::InitOutcomingPacketMark();
405 EXPECT_EQ(result, NETMANAGER_SUCCESS);
406 }
407
408 HWTEST_F(RouteManagerExtTest, UpdateOutcomingIpMark001, TestSize.Level1)
409 {
410 uint16_t netId = 103;
411 std::string addr = "10.2.0.3";
412 int32_t result = RouteManager::UpdateOutcomingIpMark(netId, addr, true);
413 EXPECT_EQ(result, NETMANAGER_SUCCESS);
414
415 result = RouteManager::UpdateOutcomingIpMark(netId, addr, false);
416 EXPECT_EQ(result, NETMANAGER_SUCCESS);
417 }
418
419 HWTEST_F(RouteManagerExtTest, UpdateOutcomingUidMark001, TestSize.Level1)
420 {
421 uint16_t netId = 103;
422 uid_t start = 2000021;
423 uid_t end = 2000021;
424 int32_t result = RouteManager::UpdateOutcomingUidMark(netId, start, end, true);
425 EXPECT_EQ(result, NETMANAGER_SUCCESS);
426
427 result = RouteManager::UpdateOutcomingUidMark(netId, start, end, false);
428 EXPECT_EQ(result, NETMANAGER_SUCCESS);
429 }
430
431 HWTEST_F(RouteManagerExtTest, UpdateVpnOutPutPenetrationRule001, TestSize.Level1)
432 {
433 uint16_t netId = 105;
434 std::string addr = "10.2.0.3";
435 std::string interfaceName = "xfrm-vpn1";
436
437 int32_t result = RouteManager::UpdateVpnOutPutPenetrationRule(netId, interfaceName, addr, true);
438 EXPECT_TRUE(result < 0);
439 result = RouteManager::UpdateVpnOutPutPenetrationRule(netId, interfaceName, addr, false);
440 EXPECT_EQ(result, NETMANAGER_SUCCESS);
441 }
442
443 HWTEST_F(RouteManagerExtTest, FindVpnIdByInterfacename001, TestSize.Level1)
444 {
445 std::string interface = "xfrm-vpn1";
446
447 uint32_t result = RouteManager::FindVpnIdByInterfacename(RouteManager::VpnRuleIdType::VPN_OUTPUT_TO_LOCAL,
448 interface);
449 EXPECT_TRUE(result > 0);
450
451 result = RouteManager::FindVpnIdByInterfacename(RouteManager::VpnRuleIdType::VPN_SECURE,
452 interface);
453 EXPECT_TRUE(result > 0);
454
455 result = RouteManager::FindVpnIdByInterfacename(RouteManager::VpnRuleIdType::VPN_EXPLICIT_NETWORK,
456 interface);
457 EXPECT_TRUE(result > 0);
458
459 result = RouteManager::FindVpnIdByInterfacename(RouteManager::VpnRuleIdType::VPN_OUTPUT_IFACE,
460 interface);
461 EXPECT_TRUE(result > 0);
462
463 result = RouteManager::FindVpnIdByInterfacename(RouteManager::VpnRuleIdType::VPN_NETWORK_TABLE,
464 interface);
465 EXPECT_TRUE(result > 0);
466
467 interface = "vpn-tun";
468 result = RouteManager::FindVpnIdByInterfacename(static_cast<RouteManager::VpnRuleIdType>(999), interface);
469 EXPECT_TRUE(result == 0);
470 }
471
472 HWTEST_F(RouteManagerExtTest, GetVpnInterffaceToId001, TestSize.Level1)
473 {
474 std::string interfaceName = "xfrm-vpn1";
475 int32_t result = RouteManager::GetVpnInterffaceToId(interfaceName);
476 EXPECT_TRUE(result == 1);
477
478 interfaceName = "vpn-tun";
479 result = RouteManager::GetVpnInterffaceToId(interfaceName);
480 EXPECT_TRUE(result == 0);
481
482 interfaceName = "ppp1";
483 result = RouteManager::GetVpnInterffaceToId(interfaceName);
484 EXPECT_TRUE(result == 0);
485
486 interfaceName = "ppp-vpn1";
487 result = RouteManager::GetVpnInterffaceToId(interfaceName);
488 EXPECT_TRUE(result == 1);
489 }
490
491 HWTEST_F(RouteManagerExtTest, GetRuleFlag001, TestSize.Level1)
492 {
493 uint32_t action = 32;
494 uint16_t result = RouteManager::GetRuleFlag(action);
495 EXPECT_TRUE(result > 0);
496
497 action = 16;
498 result = RouteManager::GetRuleFlag(action);
499 EXPECT_TRUE(result == 0);
500 }
501
502 HWTEST_F(RouteManagerExtTest, CheckMultiVpnCall001, TestSize.Level1)
503 {
504 int32_t result = RouteManager::SetVpnCallMode(TEST_SYS_VPN_CALL);
505 EXPECT_EQ(result, NETMANAGER_SUCCESS);
506
507 std::string testInterfaceName = "xfrm-vpn1";
508 EXPECT_FALSE(RouteManager::CheckMultiVpnCall(testInterfaceName));
509
510 RouteManager::vpnSysCall_ = false;
511 EXPECT_TRUE(RouteManager::CheckMultiVpnCall(testInterfaceName));
512
513 RouteManager::vpnSysCall_ = false;
514 testInterfaceName = "vpn-tun";
515 EXPECT_FALSE(RouteManager::CheckMultiVpnCall(testInterfaceName));
516
517 testInterfaceName = "";
518 EXPECT_FALSE(RouteManager::CheckMultiVpnCall(testInterfaceName));
519 }
520 } // namespace nmd
521 } // namespace OHOS