1 /*
2 * Copyright (c) 2022 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 "accesstoken_kit.h"
24 #include "iservice_registry.h"
25 #include "nativetoken_kit.h"
26 #include "token_setproc.h"
27
28 #ifdef GTEST_API_
29 #define private public
30 #endif
31 #include "net_mgr_log_wrapper.h"
32 #include "net_policy_callback_test.h"
33 #include "net_policy_client.h"
34 #include "net_policy_constants.h"
35 #include "net_policy_inner_define.h"
36 #include "net_policy_service.h"
37
38 namespace OHOS {
39 namespace NetManagerStandard {
40 namespace {
41 using namespace testing::ext;
42 using namespace Security::AccessToken;
43 using Security::AccessToken::AccessTokenID;
44 std::shared_ptr<NetPolicyClient> g_netPolicyClient = nullptr;
45 constexpr int32_t TRIGER_DELAY_US = 100000;
46 constexpr int32_t WAIT_TIME_SECOND_LONG = 10;
47 constexpr uint32_t TEST_UID = 10000;
48 const std::string TEST_STRING_PERIODDURATION = "M1";
49
50 HapInfoParams testInfoParms1 = {.userID = 1,
51 .bundleName = "net_policy_manager_test",
52 .instIndex = 0,
53 .appIDDesc = "test",
54 .isSystemApp = true};
55
56 PermissionDef testPermDef1 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
57 .bundleName = "net_policy_manager_test",
58 .grantMode = 1,
59 .availableLevel = APL_SYSTEM_BASIC,
60 .label = "label",
61 .labelId = 1,
62 .description = "Test net policy connectivity internal",
63 .descriptionId = 1};
64
65 PermissionStateFull testState1 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
66 .isGeneral = true,
67 .resDeviceID = {"local"},
68 .grantStatus = {PermissionState::PERMISSION_GRANTED},
69 .grantFlags = {2}};
70
71 HapPolicyParams testPolicyPrams1 = {.apl = APL_SYSTEM_BASIC,
72 .domain = "test.domain",
73 .permList = {testPermDef1},
74 .permStateList = {testState1}};
75
76 HapInfoParams testInfoParms2 = {.userID = 1,
77 .bundleName = "net_policy_manager_test",
78 .instIndex = 0,
79 .appIDDesc = "test",
80 .isSystemApp = true};
81
82 PermissionDef testPermDef2 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
83 .bundleName = "net_policy_manager_test",
84 .grantMode = 1,
85 .availableLevel = APL_SYSTEM_BASIC,
86 .label = "label",
87 .labelId = 1,
88 .description = "Test net policy connectivity internal",
89 .descriptionId = 1};
90
91 PermissionStateFull testState2 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
92 .isGeneral = true,
93 .resDeviceID = {"local"},
94 .grantStatus = {PermissionState::PERMISSION_GRANTED},
95 .grantFlags = {2}};
96
97 HapPolicyParams testPolicyPrams2 = {.apl = APL_SYSTEM_BASIC,
98 .domain = "test.domain",
99 .permList = {testPermDef2},
100 .permStateList = {testState2}};
101
102 HapInfoParams testInfoParms3 = {.userID = 1,
103 .bundleName = "net_policy_manager_test",
104 .instIndex = 0,
105 .appIDDesc = "test",
106 .isSystemApp = true};
107
108 PermissionDef testPermDef3 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
109 .bundleName = "net_policy_manager_test",
110 .grantMode = 1,
111 .availableLevel = APL_SYSTEM_BASIC,
112 .label = "label",
113 .labelId = 1,
114 .description = "Test net policy connectivity internal",
115 .descriptionId = 1};
116
117 PermissionStateFull testState3 = {.permissionName = "ohos.permission.MANAGE_NET_STRATEGY",
118 .isGeneral = true,
119 .resDeviceID = {"local"},
120 .grantStatus = {PermissionState::PERMISSION_GRANTED},
121 .grantFlags = {2}};
122
123 HapPolicyParams testPolicyPrams3 = {.apl = APL_SYSTEM_BASIC,
124 .domain = "test.domain",
125 .permList = {testPermDef3},
126 .permStateList = {testState3}};
127
GetQuota()128 NetQuotaPolicy GetQuota()
129 {
130 NetQuotaPolicy quotaPolicy;
131 quotaPolicy.networkmatchrule.netType = 0;
132 quotaPolicy.networkmatchrule.simId = std::to_string(TRIGER_DELAY_US);
133 quotaPolicy.quotapolicy.periodStartTime = TRIGER_DELAY_US;
134 quotaPolicy.quotapolicy.periodDuration = TEST_STRING_PERIODDURATION;
135 quotaPolicy.quotapolicy.warningBytes = TRIGER_DELAY_US;
136 quotaPolicy.quotapolicy.limitBytes = TRIGER_DELAY_US;
137 quotaPolicy.quotapolicy.lastLimitRemind = -1;
138 quotaPolicy.quotapolicy.metered = true;
139 quotaPolicy.quotapolicy.source = 0;
140 return quotaPolicy;
141 }
142 } // namespace
143
144 class AccessToken {
145 public:
AccessToken(HapInfoParams & testInfoParms,HapPolicyParams & testPolicyPrams)146 AccessToken(HapInfoParams &testInfoParms, HapPolicyParams &testPolicyPrams) : currentID_(GetSelfTokenID())
147 {
148 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testPolicyPrams);
149 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
150 SetSelfTokenID(tokenIdEx.tokenIDEx);
151 }
~AccessToken()152 ~AccessToken()
153 {
154 AccessTokenKit::DeleteToken(accessID_);
155 SetSelfTokenID(currentID_);
156 }
157
158 private:
159 AccessTokenID currentID_;
160 AccessTokenID accessID_;
161 };
162
163 class UtNetPolicyClient : public testing::Test {
164 public:
165 static void SetUpTestCase();
166 static void TearDownTestCase();
167 void SetUp();
168 void TearDown();
169 sptr<NetPolicyCallbackTest> GetINetPolicyCallbackSample() const;
170 };
171
SetUpTestCase()172 void UtNetPolicyClient::SetUpTestCase()
173 {
174 g_netPolicyClient = DelayedSingleton<NetPolicyClient>::GetInstance();
175 }
176
TearDownTestCase()177 void UtNetPolicyClient::TearDownTestCase() {}
178
SetUp()179 void UtNetPolicyClient::SetUp() {}
180
TearDown()181 void UtNetPolicyClient::TearDown() {}
182
GetINetPolicyCallbackSample() const183 sptr<NetPolicyCallbackTest> UtNetPolicyClient::GetINetPolicyCallbackSample() const
184 {
185 sptr<NetPolicyCallbackTest> callback = new (std::nothrow) NetPolicyCallbackTest();
186 return callback;
187 }
188
189 /**
190 * @tc.name: SetPolicyByUid001
191 * @tc.desc: Test NetPolicyClient SetPolicyByUid.
192 * @tc.type: FUNC
193 */
194 HWTEST_F(UtNetPolicyClient, SetPolicyByUid001, TestSize.Level1)
195 {
196 AccessToken token(testInfoParms2, testPolicyPrams2);
197 NetPolicyClient::NetPolicyDeathRecipient deathRecipient(*g_netPolicyClient);
198 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
199 sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID);
200 deathRecipient.OnRemoteDied(remote);
201 int32_t ret = g_netPolicyClient->SetPolicyByUid(TEST_UID, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
202 std::cout << "NetPolicyClient001 SetPolicyByUid ret:" << ret << std::endl;
203 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
204 }
205
206 /**
207 * @tc.name: GetPolicyByUid001
208 * @tc.desc: Test NetPolicyClient GetPolicyByUid.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(UtNetPolicyClient, GetPolicyByUid001, TestSize.Level1)
212 {
213 AccessToken token2(testInfoParms3, testPolicyPrams3);
214 uint32_t policy = 0;
215 int32_t ret = g_netPolicyClient->GetPolicyByUid(TEST_UID, policy);
216 std::cout << "NetPolicyClient002 GetPolicyByUid policy:" << policy << std::endl;
217 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
218 ASSERT_EQ(policy, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
219 }
220
221 /**
222 * @tc.name: GetUidsByPolicy001
223 * @tc.desc: Test NetPolicyClient GetUidsByPolicy.
224 * @tc.type: FUNC
225 */
226 HWTEST_F(UtNetPolicyClient, GetUidsByPolicy001, TestSize.Level1)
227 {
228 AccessToken token(testInfoParms3, testPolicyPrams3);
229 std::vector<uint32_t> uids;
230 int32_t ret = g_netPolicyClient->GetUidsByPolicy(NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND, uids);
231 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
232 ASSERT_TRUE(uids.size() > 0);
233 }
234
235 /**
236 * @tc.name: IsUidNetAllowed001
237 * @tc.desc: Test NetPolicyClient IsUidNetAllowed.
238 * @tc.type: FUNC
239 */
240 HWTEST_F(UtNetPolicyClient, IsUidNetAllowed001, TestSize.Level1)
241 {
242 AccessToken token(testInfoParms1, testPolicyPrams1);
243 bool isAllowed = false;
244 int32_t ret = g_netPolicyClient->IsUidNetAllowed(TEST_UID, false, isAllowed);
245 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
246 std::cout << "NetPolicyClient004 IsUidNetAllowed ret:" << ret << std::endl;
247 ASSERT_TRUE(isAllowed == true);
248 }
249
250 /**
251 * @tc.name: IsUidNetAllowed002
252 * @tc.desc: Test NetPolicyClient IsUidNetAllowed.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(UtNetPolicyClient, IsUidNetAllowed002, TestSize.Level1)
256 {
257 AccessToken token(testInfoParms1, testPolicyPrams1);
258 bool isAllowed = false;
259 const std::string ifaceName = "iface";
260 int32_t ret = g_netPolicyClient->IsUidNetAllowed(TEST_UID, ifaceName, isAllowed);
261 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
262 std::cout << "NetPolicyClient005 IsUidNetAllowed isAllowed:" << isAllowed << std::endl;
263 ASSERT_TRUE(isAllowed == true);
264 }
265
266 /**
267 * @tc.name: IsUidNetAccess001
268 * @tc.desc: Test NetPolicyClient IsUidNetAccess.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(UtNetPolicyClient, IsUidNetAccess001, TestSize.Level1)
272 {
273 AccessToken token(testInfoParms1, testPolicyPrams1);
274 bool isAllowed = false;
275 int32_t ret = g_netPolicyClient->IsUidNetAccess(TEST_UID, false, isAllowed);
276 std::cout << "NetPolicyClient006 IsUidNetAccess isAllowed:" << isAllowed << std::endl;
277 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
278 ASSERT_TRUE(isAllowed == true);
279 }
280
281 /**
282 * @tc.name: IsUidNetAccess002
283 * @tc.desc: Test NetPolicyClient IsUidNetAccess.
284 * @tc.type: FUNC
285 */
286 HWTEST_F(UtNetPolicyClient, IsUidNetAccess002, TestSize.Level1)
287 {
288 AccessToken token(testInfoParms1, testPolicyPrams1);
289 bool isAllowed = false;
290 const std::string ifaceName = "iface";
291 int32_t ret = g_netPolicyClient->IsUidNetAccess(TEST_UID, ifaceName, isAllowed);
292 std::cout << "NetPolicyClient007 IsUidNetAccess isAllowed:" << isAllowed << std::endl;
293 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
294 ASSERT_TRUE(isAllowed == true);
295 }
296
297 /**
298 * @tc.name: SetNetQuotaPolicies001
299 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies001, TestSize.Level1)
303 {
304 AccessToken token(testInfoParms2, testPolicyPrams2);
305 std::vector<NetQuotaPolicy> quotaPolicies;
306 quotaPolicies.push_back(GetQuota());
307 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
308 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
309 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
310 }
311
312 /**
313 * @tc.name: SetNetQuotaPolicies002
314 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies002, TestSize.Level1)
318 {
319 AccessToken token(testInfoParms2, testPolicyPrams2);
320 std::vector<NetQuotaPolicy> quotaPolicies;
321 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
322 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
323 ASSERT_EQ(ret, POLICY_ERR_INVALID_QUOTA_POLICY);
324 }
325
326 /**
327 * @tc.name: SetNetQuotaPolicies003
328 * @tc.desc: Test NetPolicyClient SetNetQuotaPolicies.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(UtNetPolicyClient, SetNetQuotaPolicies003, TestSize.Level1)
332 {
333 AccessToken token(testInfoParms2, testPolicyPrams2);
334 std::vector<NetQuotaPolicy> quotaPolicies;
335 for (int32_t i = 0; i < QUOTA_POLICY_MAX_SIZE; i++) {
336 quotaPolicies.push_back(GetQuota());
337 }
338 quotaPolicies.push_back(GetQuota());
339 int32_t ret = g_netPolicyClient->SetNetQuotaPolicies(quotaPolicies);
340 std::cout << "NetPolicyClient008 SetNetQuotaPolicies ret:" << ret << std::endl;
341 ASSERT_EQ(ret, POLICY_ERR_INVALID_QUOTA_POLICY);
342 }
343
344 /**
345 * @tc.name: GetNetQuotaPolicies001
346 * @tc.desc: Test NetPolicyClient GetNetQuotaPolicies.
347 * @tc.type: FUNC
348 */
349 HWTEST_F(UtNetPolicyClient, GetNetQuotaPolicies001, TestSize.Level1)
350 {
351 AccessToken token(testInfoParms3, testPolicyPrams3);
352 std::vector<NetQuotaPolicy> quotaPolicies;
353 int32_t ret = g_netPolicyClient->GetNetQuotaPolicies(quotaPolicies);
354 std::cout << "NetPolicyClient009 GetNetQuotaPolicies ret:" << ret << std::endl;
355 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
356 }
357
358 /**
359 * @tc.name: SetFactoryPolicy001
360 * @tc.desc: Test NetPolicyClient SetFactoryPolicy.
361 * @tc.type: FUNC
362 */
363 HWTEST_F(UtNetPolicyClient, SetFactoryPolicy001, TestSize.Level1)
364 {
365 std::string simId = "0";
366 AccessToken token(testInfoParms2, testPolicyPrams2);
367 int32_t ret = g_netPolicyClient->SetFactoryPolicy(simId);
368 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
369 }
370
371 /**
372 * @tc.name: ResetPolicies001
373 * @tc.desc: Test NetPolicyClient ResetPolicies.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(UtNetPolicyClient, ResetPolicies001, TestSize.Level1)
377 {
378 std::string simId = "0";
379 AccessToken token(testInfoParms2, testPolicyPrams2);
380 int32_t ret = g_netPolicyClient->ResetPolicies(simId);
381 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
382 }
383
384 /**
385 * @tc.name: SetBackgroundPolicy001
386 * @tc.desc: Test NetPolicyClient SetBackgroundPolicy.
387 * @tc.type: FUNC
388 */
389 HWTEST_F(UtNetPolicyClient, SetBackgroundPolicy001, TestSize.Level1)
390 {
391 AccessToken token(testInfoParms2, testPolicyPrams2);
392 int32_t ret = g_netPolicyClient->SetBackgroundPolicy(true);
393 std::cout << "NetPolicyClient012 SetBackgroundPolicy ret:" << ret << std::endl;
394 ASSERT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
395 }
396
397 /**
398 * @tc.name: GetBackgroundPolicy001
399 * @tc.desc: Test NetPolicyClient GetBackgroundPolicy.
400 * @tc.type: FUNC
401 */
402 HWTEST_F(UtNetPolicyClient, GetBackgroundPolicy001, TestSize.Level1)
403 {
404 bool backgroundPolicy;
405 AccessToken token(testInfoParms3, testPolicyPrams3);
406 int32_t ret = g_netPolicyClient->GetBackgroundPolicy(backgroundPolicy);
407 std::cout << "NetPolicyClient013 GetBackgroundPolicy ret:" << ret << std::endl;
408 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
409 ASSERT_TRUE(backgroundPolicy == true);
410 }
411
412 /**
413 * @tc.name: GetBackgroundPolicyByUid001
414 * @tc.desc: Test NetPolicyClient GetBackgroundPolicyByUid.
415 * @tc.type: FUNC
416 */
417 HWTEST_F(UtNetPolicyClient, GetBackgroundPolicyByUid001, TestSize.Level1)
418 {
419 AccessToken token(testInfoParms2, testPolicyPrams2);
420 int32_t ret1 = g_netPolicyClient->SetBackgroundPolicy(false);
421 ASSERT_EQ(ret1, NETMANAGER_SUCCESS);
422 uint32_t backgroundPolicyOfUid = 0;
423 AccessToken token2(testInfoParms1, testPolicyPrams1);
424 int32_t ret2 = g_netPolicyClient->GetBackgroundPolicyByUid(TEST_UID, backgroundPolicyOfUid);
425 ASSERT_EQ(ret2, NETMANAGER_SUCCESS);
426 ASSERT_EQ(backgroundPolicyOfUid, NET_BACKGROUND_POLICY_DISABLE);
427 }
428
429 /**
430 * @tc.name: SetSnoozePolicy001
431 * @tc.desc: Test NetPolicyClient SetSnoozePolicy.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(UtNetPolicyClient, SetSnoozePolicy001, TestSize.Level1)
435 {
436 AccessToken token(testInfoParms2, testPolicyPrams2);
437 int32_t ret = g_netPolicyClient->SetSnoozePolicy(0, std::to_string(TRIGER_DELAY_US));
438 std::cout << "NetPolicyClient015 SetSnoozePolicy ret:" << ret << std::endl;
439 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
440 }
441
442 /**
443 * @tc.name: UpdateRemindPolicy001
444 * @tc.desc: Test NetPolicyClient UpdateRemindPolicy.
445 * @tc.type: FUNC
446 */
447 HWTEST_F(UtNetPolicyClient, UpdateRemindPolicy001, TestSize.Level1)
448 {
449 AccessToken token(testInfoParms2, testPolicyPrams2);
450 int32_t ret =
451 g_netPolicyClient->UpdateRemindPolicy(0, std::to_string(TRIGER_DELAY_US), RemindType::REMIND_TYPE_LIMIT);
452 std::cout << "NetPolicyClient016 UpdateRemindPolicy ret:" << ret << std::endl;
453 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
454 }
455
456 /**
457 * @tc.name: SetIdleTrustlist001
458 * @tc.desc: Test NetPolicyClient SetIdleTrustlist.
459 * @tc.type: FUNC
460 */
461 HWTEST_F(UtNetPolicyClient, SetIdleTrustlist001, TestSize.Level1)
462 {
463 AccessToken token(testInfoParms1, testPolicyPrams1);
464 int32_t ret = g_netPolicyClient->SetIdleTrustlist(TEST_UID, true);
465 std::cout << "NetPolicyClient017 SetIdleTrustlist ret:" << ret << std::endl;
466 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
467 }
468
469 /**
470 * @tc.name: SetDeviceIdleTrustlist001
471 * @tc.desc: Test NetPolicyClient SetDeviceIdleTrustlist.
472 * @tc.type: FUNC
473 */
474 HWTEST_F(UtNetPolicyClient, SetDeviceIdleTrustlist001, TestSize.Level1)
475 {
476 AccessToken token(testInfoParms1, testPolicyPrams1);
477 int32_t ret = g_netPolicyClient->SetDeviceIdleTrustlist({TEST_UID}, true);
478 std::cout << "NetPolicyClient018 SetDeviceIdleTrustlist ret:" << ret << std::endl;
479 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
480 }
481
482 /**
483 * @tc.name: GetIdleTrustlist001
484 * @tc.desc: Test NetPolicyClient GetIdleTrustlist.
485 * @tc.type: FUNC
486 */
487 HWTEST_F(UtNetPolicyClient, GetIdleTrustlist001, TestSize.Level1)
488 {
489 std::vector<uint32_t> uids;
490 AccessToken token(testInfoParms1, testPolicyPrams1);
491 int32_t ret = g_netPolicyClient->GetIdleTrustlist(uids);
492 std::cout << "NetPolicyClient019 GetIdleTrustlist ret:" << ret << std::endl;
493 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
494 }
495
496 /**
497 * @tc.name: GetDeviceIdleTrustlist001
498 * @tc.desc: Test NetPolicyClient GetDeviceIdleTrustlist.
499 * @tc.type: FUNC
500 */
501 HWTEST_F(UtNetPolicyClient, GetDeviceIdleTrustlist001, TestSize.Level1)
502 {
503 std::vector<uint32_t> uids;
504 AccessToken token(testInfoParms1, testPolicyPrams1);
505 int32_t ret = g_netPolicyClient->GetDeviceIdleTrustlist(uids);
506 std::cout << "NetPolicyClient020 GetDeviceIdleTrustlist ret:" << ret << std::endl;
507 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
508 }
509
510 /**
511 * @tc.name: SetDeviceIdlePolicy001
512 * @tc.desc: Test NetPolicyClient SetDeviceIdlePolicy.
513 * @tc.type: FUNC
514 */
515 HWTEST_F(UtNetPolicyClient, SetDeviceIdlePolicy001, TestSize.Level1)
516 {
517 AccessToken token(testInfoParms1, testPolicyPrams1);
518 int32_t ret = g_netPolicyClient->SetDeviceIdlePolicy(true);
519 std::cout << "NetPolicyClient021 SetDeviceIdlePolicy ret:" << ret << std::endl;
520 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
521 }
522
PolicyServiceCallback()523 void PolicyServiceCallback()
524 {
525 AccessToken token(testInfoParms2, testPolicyPrams2);
526 usleep(TRIGER_DELAY_US);
527 int32_t result = DelayedSingleton<NetPolicyClient>::GetInstance()->SetPolicyByUid(
528 TEST_UID, NetUidPolicy::NET_POLICY_REJECT_METERED_BACKGROUND);
529 ASSERT_EQ(result, NETMANAGER_SUCCESS);
530 }
531 /**
532 * @tc.name: RegisterNetPolicyCallback001
533 * @tc.desc: Test NetPolicyClient RegisterNetPolicyCallback UnregisterNetPolicyCallback.
534 * @tc.type: FUNC
535 */
536 HWTEST_F(UtNetPolicyClient, RegisterNetPolicyCallback001, TestSize.Level1)
537 {
538 AccessToken token(testInfoParms1, testPolicyPrams1);
539 sptr<NetPolicyCallbackTest> callback = GetINetPolicyCallbackSample();
540 int32_t ret1 = g_netPolicyClient->RegisterNetPolicyCallback(callback);
541 if (ret1 == NETMANAGER_SUCCESS && callback != nullptr) {
542 std::thread trigerCallback(PolicyServiceCallback);
543 callback->WaitFor(WAIT_TIME_SECOND_LONG);
544 trigerCallback.join();
545 uint32_t uid = callback->GetUid();
546 uint32_t netPolicy = callback->GetPolicy();
547 std::cout << "NetPolicyClient022 RegisterNetPolicyCallback uid:" << uid
548 << " netPolicy:" << static_cast<uint32_t>(netPolicy) << std::endl;
549 ASSERT_EQ(uid, TEST_UID);
550 ASSERT_EQ(netPolicy, NetUidPolicy::NET_POLICY_REJECT_METERED_BACKGROUND);
551 ASSERT_EQ(ret1, NETMANAGER_SUCCESS);
552 } else {
553 std::cout << "NetPolicyClient022 RegisterNetPolicyCallback return fail" << std::endl;
554 }
555 AccessToken token2(testInfoParms1, testPolicyPrams1);
556 int32_t ret2 = g_netPolicyClient->UnregisterNetPolicyCallback(callback);
557 ASSERT_EQ(ret2, NETMANAGER_SUCCESS);
558 }
559 } // namespace NetManagerStandard
560 } // namespace OHOS
561