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