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 <chrono>
17 #include <condition_variable>
18 #include <mutex>
19 #include <thread>
20
21 #include <gtest/gtest.h>
22
23 #include "iservice_registry.h"
24
25 #ifdef GTEST_API_
26 #define private public
27 #endif
28 #include "net_mgr_log_wrapper.h"
29 #include "net_policy_callback_test.h"
30 #include "net_policy_client.h"
31 #include "net_policy_constants.h"
32 #include "net_policy_inner_define.h"
33 #include "net_policy_service.h"
34 #include "netmanager_base_test_security.h"
35
36 namespace OHOS {
37 namespace NetManagerStandard {
38 namespace {
39 using namespace testing::ext;
40 std::shared_ptr<NetPolicyClient> g_netPolicyClient = nullptr;
41 constexpr int32_t TRIGER_DELAY_US = 100000;
42 constexpr int32_t WAIT_TIME_SECOND_LONG = 10;
43 constexpr uint32_t TEST_UID = 10000;
44 const std::string TEST_STRING_PERIODDURATION = "M1";
45
GetQuota()46 NetQuotaPolicy GetQuota()
47 {
48 NetQuotaPolicy quotaPolicy;
49 quotaPolicy.networkmatchrule.netType = 0;
50 quotaPolicy.networkmatchrule.simId = std::to_string(TRIGER_DELAY_US);
51 quotaPolicy.quotapolicy.periodStartTime = TRIGER_DELAY_US;
52 quotaPolicy.quotapolicy.periodDuration = TEST_STRING_PERIODDURATION;
53 quotaPolicy.quotapolicy.warningBytes = TRIGER_DELAY_US;
54 quotaPolicy.quotapolicy.limitBytes = TRIGER_DELAY_US;
55 quotaPolicy.quotapolicy.lastLimitRemind = -1;
56 quotaPolicy.quotapolicy.metered = true;
57 quotaPolicy.quotapolicy.source = 0;
58 return quotaPolicy;
59 }
60 } // namespace
61
62 class UtNetPolicyClient : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp();
67 void TearDown();
68 sptr<NetPolicyCallbackTest> GetINetPolicyCallbackSample() const;
69 };
70
SetUpTestCase()71 void UtNetPolicyClient::SetUpTestCase()
72 {
73 g_netPolicyClient = DelayedSingleton<NetPolicyClient>::GetInstance();
74 }
75
TearDownTestCase()76 void UtNetPolicyClient::TearDownTestCase() {}
77
SetUp()78 void UtNetPolicyClient::SetUp() {}
79
TearDown()80 void UtNetPolicyClient::TearDown() {}
81
GetINetPolicyCallbackSample() const82 sptr<NetPolicyCallbackTest> UtNetPolicyClient::GetINetPolicyCallbackSample() const
83 {
84 sptr<NetPolicyCallbackTest> callback = new (std::nothrow) NetPolicyCallbackTest();
85 return callback;
86 }
87
88 /**
89 * @tc.name: SetPolicyByUid001
90 * @tc.desc: Test NetPolicyClient SetPolicyByUid.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UtNetPolicyClient, SetPolicyByUid001, TestSize.Level1)
94 {
95 NetManagerBaseAccessToken token;
96 NetPolicyClient::NetPolicyDeathRecipient deathRecipient(*g_netPolicyClient);
97 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
98 sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID);
99 deathRecipient.OnRemoteDied(remote);
100 int32_t ret = g_netPolicyClient->SetPolicyByUid(TEST_UID, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
101 std::cout << "NetPolicyClient001 SetPolicyByUid ret:" << ret << std::endl;
102 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
103 }
104
105 /**
106 * @tc.name: GetPolicyByUid001
107 * @tc.desc: Test NetPolicyClient GetPolicyByUid.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(UtNetPolicyClient, GetPolicyByUid001, TestSize.Level1)
111 {
112 NetManagerBaseAccessToken token;
113 uint32_t policy = 0;
114 int32_t ret = g_netPolicyClient->GetPolicyByUid(TEST_UID, policy);
115 std::cout << "NetPolicyClient002 GetPolicyByUid policy:" << policy << std::endl;
116 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
117 ASSERT_EQ(policy, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
118 }
119
120 /**
121 * @tc.name: GetUidsByPolicy001
122 * @tc.desc: Test NetPolicyClient GetUidsByPolicy.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(UtNetPolicyClient, GetUidsByPolicy001, TestSize.Level1)
126 {
127 NetManagerBaseAccessToken token;
128 std::vector<uint32_t> uids;
129 int32_t ret = g_netPolicyClient->GetUidsByPolicy(NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND, uids);
130 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
131 ASSERT_TRUE(uids.size() > 0);
132 }
133
134 /**
135 * @tc.name: IsUidNetAllowed001
136 * @tc.desc: Test NetPolicyClient IsUidNetAllowed.
137 * @tc.type: FUNC
138 */
139 HWTEST_F(UtNetPolicyClient, IsUidNetAllowed001, TestSize.Level1)
140 {
141 NetManagerBaseAccessToken token;
142 bool isAllowed = false;
143 int32_t ret = g_netPolicyClient->IsUidNetAllowed(TEST_UID, false, isAllowed);
144 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
145 std::cout << "NetPolicyClient004 IsUidNetAllowed ret:" << ret << std::endl;
146 ASSERT_TRUE(isAllowed == true);
147 }
148
149 /**
150 * @tc.name: IsUidNetAllowed002
151 * @tc.desc: Test NetPolicyClient IsUidNetAllowed.
152 * @tc.type: FUNC
153 */
154 HWTEST_F(UtNetPolicyClient, IsUidNetAllowed002, TestSize.Level1)
155 {
156 NetManagerBaseAccessToken token;
157 bool isAllowed = false;
158 const std::string ifaceName = "iface";
159 int32_t ret = g_netPolicyClient->IsUidNetAllowed(TEST_UID, ifaceName, isAllowed);
160 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
161 std::cout << "NetPolicyClient005 IsUidNetAllowed isAllowed:" << isAllowed << std::endl;
162 ASSERT_TRUE(isAllowed == true);
163 }
164
165 /**
166 * @tc.name: IsUidNetAccess001
167 * @tc.desc: Test NetPolicyClient IsUidNetAccess.
168 * @tc.type: FUNC
169 */
170 HWTEST_F(UtNetPolicyClient, IsUidNetAccess001, TestSize.Level1)
171 {
172 NetManagerBaseAccessToken token;
173 bool isAllowed = false;
174 int32_t ret = g_netPolicyClient->IsUidNetAccess(TEST_UID, false, isAllowed);
175 std::cout << "NetPolicyClient006 IsUidNetAccess isAllowed:" << isAllowed << std::endl;
176 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
177 ASSERT_TRUE(isAllowed == true);
178 }
179
180 /**
181 * @tc.name: IsUidNetAccess002
182 * @tc.desc: Test NetPolicyClient IsUidNetAccess.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(UtNetPolicyClient, IsUidNetAccess002, TestSize.Level1)
186 {
187 NetManagerBaseAccessToken token;
188 bool isAllowed = false;
189 const std::string ifaceName = "iface";
190 int32_t ret = g_netPolicyClient->IsUidNetAccess(TEST_UID, ifaceName, isAllowed);
191 std::cout << "NetPolicyClient007 IsUidNetAccess isAllowed:" << isAllowed << std::endl;
192 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
193 ASSERT_TRUE(isAllowed == true);
194 }
195
196 /**
197 * @tc.name: SetNetQuotaPolicies001
198 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies001, TestSize.Level1)
202 {
203 NetManagerBaseAccessToken token;
204 std::vector<NetQuotaPolicy> quotaPolicies;
205 quotaPolicies.push_back(GetQuota());
206 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
207 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
208 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
209 }
210
211 /**
212 * @tc.name: SetNetQuotaPolicies002
213 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies002, TestSize.Level1)
217 {
218 NetManagerBaseAccessToken token;
219 std::vector<NetQuotaPolicy> quotaPolicies;
220 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
221 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
222 ASSERT_EQ(ret, POLICY_ERR_INVALID_QUOTA_POLICY);
223 }
224
225 /**
226 * @tc.name: SetNetQuotaPolicies003
227 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
228 * @tc.type: FUNC
229 */
230 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies003, TestSize.Level1)
231 {
232 NetManagerBaseAccessToken token;
233 std::vector<NetQuotaPolicy> quotaPolicies;
234 for (int32_t i = 0; i < QUOTA_POLICY_MAX_SIZE; i++) {
235 quotaPolicies.push_back(GetQuota());
236 }
237 quotaPolicies.push_back(GetQuota());
238 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
239 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
240 ASSERT_EQ(ret, POLICY_ERR_INVALID_QUOTA_POLICY);
241 }
242
243 /**
244 * @tc.name: GetNetQuotaPolicies001
245 * @tc.desc: Test NetPolicyClient GetNetQuotaPolicies.
246 * @tc.type: FUNC
247 */
248 HWTEST_F(UtNetPolicyClient, GetNetQuotaPolicies001, TestSize.Level1)
249 {
250 NetManagerBaseAccessToken token;
251 std::vector<NetQuotaPolicy> quotaPolicies;
252 int32_t ret = g_netPolicyClient->GetNetQuotaPolicies(quotaPolicies);
253 std::cout << "NetPolicyClient009 GetNetQuotaPolicies ret:" << ret << std::endl;
254 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
255 }
256
257 /**
258 * @tc.name: SetFactoryPolicy001
259 * @tc.desc: Test NetPolicyClient SetFactoryPolicy.
260 * @tc.type: FUNC
261 */
262 HWTEST_F(UtNetPolicyClient, SetFactoryPolicy001, TestSize.Level1)
263 {
264 std::string simId = "0";
265 NetManagerBaseAccessToken token;
266 int32_t ret = g_netPolicyClient->SetFactoryPolicy(simId);
267 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
268 }
269
270 /**
271 * @tc.name: ResetPolicies001
272 * @tc.desc: Test NetPolicyClient ResetPolicies.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(UtNetPolicyClient, ResetPolicies001, TestSize.Level1)
276 {
277 std::string simId = "0";
278 NetManagerBaseAccessToken token;
279 int32_t ret = g_netPolicyClient->ResetPolicies(simId);
280 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
281 }
282
283 /**
284 * @tc.name: SetBackgroundPolicy001
285 * @tc.desc: Test NetPolicyClient SetBackgroundPolicy.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(UtNetPolicyClient, SetBackgroundPolicy001, TestSize.Level1)
289 {
290 NetManagerBaseAccessToken token;
291 int32_t ret = g_netPolicyClient->SetBackgroundPolicy(true);
292 std::cout << "NetPolicyClient012 SetBackgroundPolicy ret:" << ret << std::endl;
293 ASSERT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
294 }
295
296 /**
297 * @tc.name: GetBackgroundPolicy001
298 * @tc.desc: Test NetPolicyClient GetBackgroundPolicy.
299 * @tc.type: FUNC
300 */
301 HWTEST_F(UtNetPolicyClient, GetBackgroundPolicy001, TestSize.Level1)
302 {
303 bool backgroundPolicy;
304 NetManagerBaseAccessToken token;
305 int32_t ret = g_netPolicyClient->GetBackgroundPolicy(backgroundPolicy);
306 std::cout << "NetPolicyClient013 GetBackgroundPolicy ret:" << ret << std::endl;
307 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
308 ASSERT_TRUE(backgroundPolicy == true);
309 }
310
311 /**
312 * @tc.name: GetBackgroundPolicyByUid001
313 * @tc.desc: Test NetPolicyClient GetBackgroundPolicyByUid.
314 * @tc.type: FUNC
315 */
316 HWTEST_F(UtNetPolicyClient, GetBackgroundPolicyByUid001, TestSize.Level1)
317 {
318 NetManagerBaseAccessToken token;
319 int32_t ret1 = g_netPolicyClient->SetBackgroundPolicy(false);
320 ASSERT_EQ(ret1, NETMANAGER_SUCCESS);
321 uint32_t backgroundPolicyOfUid = 0;
322
323 int32_t ret2 = g_netPolicyClient->GetBackgroundPolicyByUid(TEST_UID, backgroundPolicyOfUid);
324 ASSERT_EQ(ret2, NETMANAGER_SUCCESS);
325 ASSERT_EQ(backgroundPolicyOfUid, NET_BACKGROUND_POLICY_DISABLE);
326 }
327
328 /**
329 * @tc.name: SetSnoozePolicy001
330 * @tc.desc: Test NetPolicyClient SetSnoozePolicy.
331 * @tc.type: FUNC
332 */
333 HWTEST_F(UtNetPolicyClient, SetSnoozePolicy001, TestSize.Level1)
334 {
335 NetManagerBaseAccessToken token;
336 int32_t ret = g_netPolicyClient->SetSnoozePolicy(0, std::to_string(TRIGER_DELAY_US));
337 std::cout << "NetPolicyClient015 SetSnoozePolicy ret:" << ret << std::endl;
338 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
339 }
340
341 /**
342 * @tc.name: UpdateRemindPolicy001
343 * @tc.desc: Test NetPolicyClient UpdateRemindPolicy.
344 * @tc.type: FUNC
345 */
346 HWTEST_F(UtNetPolicyClient, UpdateRemindPolicy001, TestSize.Level1)
347 {
348 NetManagerBaseAccessToken token;
349 int32_t ret =
350 g_netPolicyClient->UpdateRemindPolicy(0, std::to_string(TRIGER_DELAY_US), RemindType::REMIND_TYPE_LIMIT);
351 std::cout << "NetPolicyClient016 UpdateRemindPolicy ret:" << ret << std::endl;
352 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
353 }
354
355 /**
356 * @tc.name: SetIdleTrustlist001
357 * @tc.desc: Test NetPolicyClient SetIdleTrustlist.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(UtNetPolicyClient, SetIdleTrustlist001, TestSize.Level1)
361 {
362 NetManagerBaseAccessToken token;
363 int32_t ret = g_netPolicyClient->SetIdleTrustlist(TEST_UID, true);
364 std::cout << "NetPolicyClient017 SetIdleTrustlist ret:" << ret << std::endl;
365 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
366 }
367
368 /**
369 * @tc.name: SetDeviceIdleTrustlist001
370 * @tc.desc: Test NetPolicyClient SetDeviceIdleTrustlist.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(UtNetPolicyClient, SetDeviceIdleTrustlist001, TestSize.Level1)
374 {
375 NetManagerBaseAccessToken token;
376 int32_t ret = g_netPolicyClient->SetDeviceIdleTrustlist({TEST_UID}, true);
377 std::cout << "NetPolicyClient018 SetDeviceIdleTrustlist ret:" << ret << std::endl;
378 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
379 }
380
381 /**
382 * @tc.name: GetIdleTrustlist001
383 * @tc.desc: Test NetPolicyClient GetIdleTrustlist.
384 * @tc.type: FUNC
385 */
386 HWTEST_F(UtNetPolicyClient, GetIdleTrustlist001, TestSize.Level1)
387 {
388 std::vector<uint32_t> uids;
389 NetManagerBaseAccessToken token;
390 int32_t ret = g_netPolicyClient->GetIdleTrustlist(uids);
391 std::cout << "NetPolicyClient019 GetIdleTrustlist ret:" << ret << std::endl;
392 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
393 }
394
395 /**
396 * @tc.name: GetDeviceIdleTrustlist001
397 * @tc.desc: Test NetPolicyClient GetDeviceIdleTrustlist.
398 * @tc.type: FUNC
399 */
400 HWTEST_F(UtNetPolicyClient, GetDeviceIdleTrustlist001, TestSize.Level1)
401 {
402 std::vector<uint32_t> uids;
403 NetManagerBaseAccessToken token;
404 int32_t ret = g_netPolicyClient->GetDeviceIdleTrustlist(uids);
405 std::cout << "NetPolicyClient020 GetDeviceIdleTrustlist ret:" << ret << std::endl;
406 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
407 }
408
409 /**
410 * @tc.name: SetDeviceIdlePolicy001
411 * @tc.desc: Test NetPolicyClient SetDeviceIdlePolicy.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(UtNetPolicyClient, SetDeviceIdlePolicy001, TestSize.Level1)
415 {
416 NetManagerBaseAccessToken token;
417 int32_t ret = g_netPolicyClient->SetDeviceIdlePolicy(true);
418 std::cout << "NetPolicyClient021 SetDeviceIdlePolicy ret:" << ret << std::endl;
419 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
420 }
421
PolicyServiceCallback()422 void PolicyServiceCallback()
423 {
424 NetManagerBaseAccessToken token;
425 usleep(TRIGER_DELAY_US);
426 int32_t result = DelayedSingleton<NetPolicyClient>::GetInstance()->SetPolicyByUid(
427 TEST_UID, NetUidPolicy::NET_POLICY_REJECT_METERED_BACKGROUND);
428 ASSERT_EQ(result, NETMANAGER_SUCCESS);
429 }
430 /**
431 * @tc.name: RegisterNetPolicyCallback001
432 * @tc.desc: Test NetPolicyClient RegisterNetPolicyCallback UnregisterNetPolicyCallback.
433 * @tc.type: FUNC
434 */
435 HWTEST_F(UtNetPolicyClient, RegisterNetPolicyCallback001, TestSize.Level1)
436 {
437 NetManagerBaseAccessToken token;
438 sptr<NetPolicyCallbackTest> callback = GetINetPolicyCallbackSample();
439 int32_t ret1 = g_netPolicyClient->RegisterNetPolicyCallback(callback);
440 if (ret1 == NETMANAGER_SUCCESS && callback != nullptr) {
441 std::thread trigerCallback(PolicyServiceCallback);
442 callback->WaitFor(WAIT_TIME_SECOND_LONG);
443 trigerCallback.join();
444 uint32_t uid = callback->GetUid();
445 uint32_t netPolicy = callback->GetPolicy();
446 std::cout << "NetPolicyClient022 RegisterNetPolicyCallback uid:" << uid
447 << " netPolicy:" << static_cast<uint32_t>(netPolicy) << std::endl;
448 ASSERT_EQ(uid, TEST_UID);
449 ASSERT_EQ(netPolicy, NetUidPolicy::NET_POLICY_REJECT_METERED_BACKGROUND);
450 ASSERT_EQ(ret1, NETMANAGER_SUCCESS);
451 } else {
452 std::cout << "NetPolicyClient022 RegisterNetPolicyCallback return fail" << std::endl;
453 }
454 NetManagerBaseAccessToken token1;
455 int32_t ret2 = g_netPolicyClient->UnregisterNetPolicyCallback(callback);
456 ASSERT_EQ(ret2, NETMANAGER_SUCCESS);
457 }
458
459 /**
460 * @tc.name: GetPowerSaveTrustlist001
461 * @tc.desc: Test NetPolicyClient GetPowerSaveTrustlist.
462 * @tc.type: FUNC
463 */
464 HWTEST_F(UtNetPolicyClient, GetPowerSaveTrustlist001, TestSize.Level1)
465 {
466 NetManagerBaseAccessToken token;
467 std::vector<uint32_t> uids;
468 int32_t ret = g_netPolicyClient->GetPowerSaveTrustlist(uids);
469 std::cout << "NetPolicyClient023 GetPowerSaveTrustlist ret:" << ret << std::endl;
470 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
471 }
472
473 /**
474 * @tc.name: SetPowerSaveTrustlist001
475 * @tc.desc: Test NetPolicyClient SetPowerSaveTrustlist.
476 * @tc.type: FUNC
477 */
478 HWTEST_F(UtNetPolicyClient, SetPowerSaveTrustlist001, TestSize.Level1)
479 {
480 NetManagerBaseAccessToken token;
481 std::vector<uint32_t> uids;
482 bool isAllowed = true;
483 int32_t ret = g_netPolicyClient->SetPowerSaveTrustlist(uids, isAllowed);
484 std::cout << "NetPolicyClient024 SetPowerSaveTrustlist ret:" << ret << std::endl;
485 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
486 }
487
488 /**
489 * @tc.name: SetPowerSavePolicy001
490 * @tc.desc: Test NetPolicyClient SetPowerSavePolicy.
491 * @tc.type: FUNC
492 */
493 HWTEST_F(UtNetPolicyClient, SetPowerSavePolicy001, TestSize.Level1)
494 {
495 NetManagerBaseAccessToken token;
496 bool enable = true;
497 int32_t ret = g_netPolicyClient->SetPowerSavePolicy(enable);
498 std::cout << "NetPolicyClient025 SetPowerSavePolicy ret:" << ret << std::endl;
499 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
500 }
501
502 /**
503 * @tc.name: CheckPermission001
504 * @tc.desc: Test NetPolicyClient CheckPermission.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(UtNetPolicyClient, CheckPermission001, TestSize.Level1)
508 {
509 NetManagerBaseAccessToken token;
510 int32_t ret = g_netPolicyClient->CheckPermission();
511 std::cout << "NetPolicyClient026 CheckPermission ret:" << ret << std::endl;
512 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
513 }
514
515 /**
516 * @tc.name: SetNetworkAccessPolicy001
517 * @tc.desc: Test NetPolicyClient SetNetworkAccessPolicy.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(UtNetPolicyClient, SetNetworkAccessPolicy001, TestSize.Level1)
521 {
522 NetManagerBaseAccessToken token;
523 NetworkAccessPolicy netAccessPolicy;
524 netAccessPolicy.wifiAllow = false;
525 netAccessPolicy.cellularAllow = false;
526 bool reconfirmFlag = true;
527
528 int32_t result1 = g_netPolicyClient->SetNetworkAccessPolicy(
529 TEST_UID, netAccessPolicy, reconfirmFlag);
530 std::cout << "NetPolicyClient025 SetNetworkAccessPolicy ret:" << result1 << std::endl;
531 ASSERT_EQ(result1, NETMANAGER_SUCCESS);
532 }
533
534 /**
535 * @tc.name: GetNetworkAccessPolicy001
536 * @tc.desc: Test NetPolicyClient GetNetworkAccessPolicy.
537 * @tc.type: FUNC
538 */
539 HWTEST_F(UtNetPolicyClient, GetNetworkAccessPolicy001, TestSize.Level1)
540 {
541 NetManagerBaseAccessToken token;
542 AccessPolicyParameter parameter;
543 parameter.flag = 1;
544 parameter.uid = TEST_UID;
545 AccessPolicySave resultSave;
546
547 int32_t result1 = g_netPolicyClient->GetNetworkAccessPolicy(parameter, resultSave);
548 std::cout << "NetPolicyClient026 GetNetworkAccessPolicy ret:" << result1 << std::endl;
549 ASSERT_EQ(result1, NETMANAGER_SUCCESS);
550 }
551
552 /**
553 * @tc.name: NotifyNetAccessPolicyDiag001
554 * @tc.desc: Test NetPolicyClient NotifyNetAccessPolicyDiag.
555 * @tc.type: FUNC
556 */
557 HWTEST_F(UtNetPolicyClient, NotifyNetAccessPolicyDiag001, TestSize.Level1)
558 {
559 NetManagerBaseAccessToken token;
560 uint32_t uid = 0;
561 int32_t result = g_netPolicyClient->NotifyNetAccessPolicyDiag(uid);
562 std::cout << "NetPolicyClient027 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
563 ASSERT_TRUE(result == NETMANAGER_SUCCESS || result == NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
564 }
565
566 /**
567 * @tc.name: SetNicTrafficAllowed001
568 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
569 * @tc.type: FUNC
570 */
571 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed001, TestSize.Level1)
572 {
573 NetManagerBaseAccessToken token;
574 std::vector<std::string> ifaceName = {};
575 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, false);
576 std::cout << "NetPolicyClient028 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
577 ASSERT_EQ(result, NETMANAGER_SUCCESS);
578 }
579
580 /**
581 * @tc.name: SetNicTrafficAllowed002
582 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed002, TestSize.Level1)
586 {
587 NetManagerBaseAccessToken token;
588 std::vector<std::string> ifaceName = {};
589 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, true);
590 std::cout << "NetPolicyClient029 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
591 ASSERT_EQ(result, NETMANAGER_SUCCESS);
592 }
593
594 /**
595 * @tc.name: SetNicTrafficAllowed003
596 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
597 * @tc.type: FUNC
598 */
599 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed003, TestSize.Level1)
600 {
601 NetManagerBaseAccessToken token;
602 std::vector<std::string> ifaceName = {"wlan0"};
603 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, false);
604 std::cout << "NetPolicyClient030 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
605 ASSERT_EQ(result, NETMANAGER_SUCCESS);
606 }
607
608 /**
609 * @tc.name: SetNicTrafficAllowed004
610 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
611 * @tc.type: FUNC
612 */
613 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed004, TestSize.Level1)
614 {
615 NetManagerBaseAccessToken token;
616 std::vector<std::string> ifaceName = {"wlan0"};
617 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, true);
618 std::cout << "NetPolicyClient031 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
619 ASSERT_EQ(result, NETMANAGER_SUCCESS);
620 }
621
622 /**
623 * @tc.name: SetNicTrafficAllowed005
624 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
625 * @tc.type: FUNC
626 */
627 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed005, TestSize.Level1)
628 {
629 NetManagerBaseAccessToken token;
630 std::vector<std::string> ifaceName = {"wlan0", "aaa"};
631 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, false);
632 std::cout << "NetPolicyClient032 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
633 ASSERT_EQ(result, NETMANAGER_SUCCESS);
634 }
635
636 /**
637 * @tc.name: SetNicTrafficAllowed006
638 * @tc.desc: Test NetPolicyClient SetNicTrafficAllowed.
639 * @tc.type: FUNC
640 */
641 HWTEST_F(UtNetPolicyClient, SetNicTrafficAllowed006, TestSize.Level1)
642 {
643 NetManagerBaseAccessToken token;
644 std::vector<std::string> ifaceName = {"wlan0", "aaa"};
645 int32_t result = g_netPolicyClient->SetNicTrafficAllowed(ifaceName, true);
646 std::cout << "NetPolicyClient027 NotifyNetAccessPolicyDiag ret:" << result << std::endl;
647 ASSERT_EQ(result, NETMANAGER_SUCCESS);
648 }
649
650 /**
651 * @tc.name: OnRemoteDied001
652 * @tc.desc: Test NetPolicyClient OnRemoteDied.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(UtNetPolicyClient, OnRemoteDied001, TestSize.Level1)
656 {
657 const wptr<IRemoteObject> remote = nullptr;
658 g_netPolicyClient->OnRemoteDied(remote);
659 EXPECT_EQ(remote, nullptr);
660 }
661 } // namespace NetManagerStandard
662 } // namespace OHOS
663