1 /*
2 * Copyright (c) 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 <vector>
17
18 #include <gtest/gtest.h>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24 #include "net_policy_service_stub.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
28 namespace {
29 #define DTEST_LOG std::cout << __func__ << ":" << __LINE__ << ":"
30 constexpr const char *ETH_IFACE_NAME = "lo";
31 constexpr int32_t TEST_UID = 1010;
32 class MockNetPolicyServiceStubTest : public NetPolicyServiceStub {
33 public:
34 MockNetPolicyServiceStubTest() = default;
35 ~MockNetPolicyServiceStubTest() = default;
SetPolicyByUid(uint32_t uid,uint32_t policy)36 int32_t SetPolicyByUid(uint32_t uid, uint32_t policy) override
37 {
38 return 0;
39 }
40
GetPolicyByUid(uint32_t uid,uint32_t & policy)41 int32_t GetPolicyByUid(uint32_t uid, uint32_t &policy) override
42 {
43 return 0;
44 }
45
GetUidsByPolicy(uint32_t policy,std::vector<uint32_t> & uids)46 int32_t GetUidsByPolicy(uint32_t policy, std::vector<uint32_t> &uids) override
47 {
48 return 0;
49 }
50
IsUidNetAllowed(uint32_t uid,bool metered,bool & isAllowed)51 int32_t IsUidNetAllowed(uint32_t uid, bool metered, bool &isAllowed) override
52 {
53 return 0;
54 }
55
IsUidNetAllowed(uint32_t uid,const std::string & ifaceName,bool & isAllowed)56 int32_t IsUidNetAllowed(uint32_t uid, const std::string &ifaceName, bool &isAllowed) override
57 {
58 return 0;
59 }
60
RegisterNetPolicyCallback(const sptr<INetPolicyCallback> & callback)61 int32_t RegisterNetPolicyCallback(const sptr<INetPolicyCallback> &callback) override
62 {
63 return 0;
64 }
65
UnregisterNetPolicyCallback(const sptr<INetPolicyCallback> & callback)66 int32_t UnregisterNetPolicyCallback(const sptr<INetPolicyCallback> &callback) override
67 {
68 return 0;
69 }
70
SetNetQuotaPolicies(const std::vector<NetQuotaPolicy> & quotaPolicies)71 int32_t SetNetQuotaPolicies(const std::vector<NetQuotaPolicy> "aPolicies) override
72 {
73 return 0;
74 }
75
GetNetQuotaPolicies(std::vector<NetQuotaPolicy> & quotaPolicies)76 int32_t GetNetQuotaPolicies(std::vector<NetQuotaPolicy> "aPolicies) override
77 {
78 return 0;
79 }
80
UpdateRemindPolicy(int32_t netType,const std::string & simId,uint32_t remindType)81 int32_t UpdateRemindPolicy(int32_t netType, const std::string &simId, uint32_t remindType) override
82 {
83 return 0;
84 }
85
SetDeviceIdleTrustlist(const std::vector<uint32_t> & uids,bool isAllowed)86 int32_t SetDeviceIdleTrustlist(const std::vector<uint32_t> &uids, bool isAllowed) override
87 {
88 return 0;
89 }
90
GetDeviceIdleTrustlist(std::vector<uint32_t> & uids)91 int32_t GetDeviceIdleTrustlist(std::vector<uint32_t> &uids) override
92 {
93 return 0;
94 }
95
SetDeviceIdlePolicy(bool enable)96 int32_t SetDeviceIdlePolicy(bool enable) override
97 {
98 return 0;
99 }
100
ResetPolicies(const std::string & simId)101 int32_t ResetPolicies(const std::string &simId) override
102 {
103 return 0;
104 }
105
SetBackgroundPolicy(bool isAllowed)106 int32_t SetBackgroundPolicy(bool isAllowed) override
107 {
108 return 0;
109 }
110
GetBackgroundPolicy(bool & backgroundPolicy)111 int32_t GetBackgroundPolicy(bool &backgroundPolicy) override
112 {
113 return 0;
114 }
115
GetBackgroundPolicyByUid(uint32_t uid,uint32_t & backgroundPolicyOfUid)116 int32_t GetBackgroundPolicyByUid(uint32_t uid, uint32_t &backgroundPolicyOfUid) override
117 {
118 return 0;
119 }
120
GetPowerSaveTrustlist(std::vector<uint32_t> & uids)121 int32_t GetPowerSaveTrustlist(std::vector<uint32_t> &uids) override
122 {
123 return 0;
124 }
125
SetPowerSaveTrustlist(const std::vector<uint32_t> & uids,bool isAllowed)126 int32_t SetPowerSaveTrustlist(const std::vector<uint32_t> &uids, bool isAllowed) override
127 {
128 return 0;
129 }
130
SetPowerSavePolicy(bool enable)131 int32_t SetPowerSavePolicy(bool enable) override
132 {
133 return 0;
134 }
135
CheckPermission()136 int32_t CheckPermission() override
137 {
138 return 0;
139 }
140
FactoryResetPolicies()141 int32_t FactoryResetPolicies() override
142 {
143 return 0;
144 }
145
SetNetworkAccessPolicy(uint32_t uid,NetworkAccessPolicy policy,bool reconfirmFlag)146 int32_t SetNetworkAccessPolicy(uint32_t uid, NetworkAccessPolicy policy, bool reconfirmFlag) override
147 {
148 return 0;
149 }
150
GetNetworkAccessPolicy(AccessPolicyParameter parameter,AccessPolicySave & policy)151 int32_t GetNetworkAccessPolicy(AccessPolicyParameter parameter, AccessPolicySave& policy) override
152 {
153 return 0;
154 }
155
NotifyNetAccessPolicyDiag(uint32_t uid)156 int32_t NotifyNetAccessPolicyDiag(uint32_t uid) override
157 {
158 return 0;
159 }
160
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)161 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
162 {
163 bool byPassPolicyPermission = false;
164 if (!data.ReadBool(byPassPolicyPermission)) {
165 return NETMANAGER_ERR_READ_DATA_FAIL;
166 }
167
168 if (!byPassPolicyPermission) {
169 return NetPolicyServiceStub::OnRemoteRequest(code, data, reply, option);
170 }
171
172 auto itFunc = memberFuncMap_.find(code);
173 int32_t result = NETMANAGER_SUCCESS;
174 if (itFunc != memberFuncMap_.end()) {
175 auto requestFunc = itFunc->second;
176 if (requestFunc != nullptr) {
177 result = (this->*requestFunc)(data, reply);
178 return result;
179 }
180 }
181
182 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
183 }
184
SetNicTrafficAllowed(const std::vector<std::string> & ifaceNames,bool status)185 int32_t SetNicTrafficAllowed(const std::vector<std::string> &ifaceNames, bool status) override
186 {
187 return 0;
188 }
189 };
190
191 } // namespace
192
193 using namespace testing::ext;
194 class NetPolicyServiceStubTest : public testing::Test {
195 public:
196 static void SetUpTestCase();
197 static void TearDownTestCase();
198 void SetUp();
199 void TearDown();
200
201 static inline sptr<NetPolicyServiceStub> instance_ = new (std::nothrow) MockNetPolicyServiceStubTest();
202 };
203
SetUpTestCase()204 void NetPolicyServiceStubTest::SetUpTestCase() {}
205
TearDownTestCase()206 void NetPolicyServiceStubTest::TearDownTestCase()
207 {
208 instance_ = nullptr;
209 }
210
SetUp()211 void NetPolicyServiceStubTest::SetUp() {}
212
TearDown()213 void NetPolicyServiceStubTest::TearDown() {}
214
215 /**
216 * @tc.name: OnRemoteRequestTest001
217 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
218 * @tc.type: FUNC
219 */
220 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest001, TestSize.Level1)
221 {
222 MessageParcel data;
223 MessageParcel reply;
224 MessageOption option;
225 data.WriteBool(false);
226 int32_t ret =
227 instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_END), data, reply, option);
228 EXPECT_EQ(ret, NETMANAGER_ERR_DESCRIPTOR_MISMATCH);
229 }
230
231 /**
232 * @tc.name: OnRemoteRequestTest002
233 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest002, TestSize.Level1)
237 {
238 MessageParcel data;
239 data.WriteBool(false);
240 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
241 return;
242 }
243 MessageParcel reply;
244 MessageOption option;
245 int32_t ret =
246 instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_END), data, reply, option);
247 EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
248 }
249
250 /**
251 * @tc.name: OnRemoteRequestTest003
252 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest003, TestSize.Level1)
256 {
257 MessageParcel data;
258 data.WriteBool(false);
259 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
260 return;
261 }
262 MessageParcel reply;
263 MessageOption option;
264 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID),
265 data, reply, option);
266 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
267
268 int32_t result = NETMANAGER_ERROR;
269 EXPECT_EQ(reply.ReadInt32(result), true);
270 EXPECT_EQ(result, NETMANAGER_ERR_PERMISSION_DENIED);
271 }
272
273 /**
274 * @tc.name: OnSetPolicyByUidTest001
275 * @tc.desc: Test NetPolicyServiceStub OnSetPolicyByUid.
276 * @tc.type: FUNC
277 */
278 HWTEST_F(NetPolicyServiceStubTest, OnSetPolicyByUidTest001, TestSize.Level1)
279 {
280 MessageParcel data;
281 data.WriteBool(true);
282 data.WriteUint32(TEST_UID);
283 data.WriteUint32(0);
284 MessageParcel reply;
285 MessageOption option;
286 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID),
287 data, reply, option);
288 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
289 }
290
291 /**
292 * @tc.name: OnGetPolicyByUidTest001
293 * @tc.desc: Test NetPolicyServiceStub OnGetPolicyByUid.
294 * @tc.type: FUNC
295 */
296 HWTEST_F(NetPolicyServiceStubTest, OnGetPolicyByUidTest001, TestSize.Level1)
297 {
298 MessageParcel data;
299 data.WriteBool(true);
300 data.WriteUint32(TEST_UID);
301 MessageParcel reply;
302 MessageOption option;
303 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID),
304 data, reply, option);
305 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
306 }
307
308 /**
309 * @tc.name: OnGetUidsByPolicyTest001
310 * @tc.desc: Test NetPolicyServiceStub OnGetUidsByPolicy.
311 * @tc.type: FUNC
312 */
313 HWTEST_F(NetPolicyServiceStubTest, OnGetUidsByPolicyTest001, TestSize.Level1)
314 {
315 MessageParcel data;
316 data.WriteBool(true);
317 data.WriteUint32(TEST_UID);
318 MessageParcel reply;
319 MessageOption option;
320 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY),
321 data, reply, option);
322 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
323 }
324
325 /**
326 * @tc.name: OnIsUidNetAllowedMeteredTest001
327 * @tc.desc: Test NetPolicyServiceStub OnIsUidNetAllowedMetered.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(NetPolicyServiceStubTest, OnIsUidNetAllowedMeteredTest001, TestSize.Level1)
331 {
332 MessageParcel data;
333 data.WriteBool(true);
334 data.WriteUint32(TEST_UID);
335 data.WriteBool(true);
336 MessageParcel reply;
337 MessageOption option;
338 int32_t ret = instance_->OnRemoteRequest(
339 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED), data, reply, option);
340 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
341 }
342
343 /**
344 * @tc.name: OnIsUidNetAllowedIfaceNameTest001
345 * @tc.desc: Test NetPolicyServiceStub OnIsUidNetAllowedIfaceName.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(NetPolicyServiceStubTest, OnIsUidNetAllowedIfaceNameTest001, TestSize.Level1)
349 {
350 MessageParcel data;
351 data.WriteBool(true);
352 data.WriteUint32(TEST_UID);
353 data.WriteString(ETH_IFACE_NAME);
354 MessageParcel reply;
355 MessageOption option;
356 int32_t ret = instance_->OnRemoteRequest(
357 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE), data, reply, option);
358 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
359 }
360
361 /**
362 * @tc.name: OnSetNetQuotaPoliciesTest001
363 * @tc.desc: Test NetPolicyServiceStub OnSetNetQuotaPolicies.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(NetPolicyServiceStubTest, OnSetNetQuotaPoliciesTest001, TestSize.Level1)
367 {
368 MessageParcel data;
369 data.WriteBool(true);
370 NetQuotaPolicy quotaPolicy;
371 quotaPolicy.quotapolicy.title = "test";
372 std::vector<NetQuotaPolicy> quotaPolicies;
373 quotaPolicies.emplace_back(quotaPolicy);
374 NetQuotaPolicy::Marshalling(data, quotaPolicies);
375 MessageParcel reply;
376 MessageOption option;
377 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES),
378 data, reply, option);
379 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
380 }
381
382 /**
383 * @tc.name: OnGetNetQuotaPoliciesTest001
384 * @tc.desc: Test NetPolicyServiceStub OnGetNetQuotaPolicies.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(NetPolicyServiceStubTest, OnGetNetQuotaPoliciesTest001, TestSize.Level1)
388 {
389 MessageParcel data;
390 data.WriteBool(true);
391 MessageParcel reply;
392 MessageOption option;
393 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES),
394 data, reply, option);
395 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
396 }
397
398 /**
399 * @tc.name: OnResetPoliciesTest001
400 * @tc.desc: Test NetPolicyServiceStub OnResetPolicies.
401 * @tc.type: FUNC
402 */
403 HWTEST_F(NetPolicyServiceStubTest, OnResetPoliciesTest001, TestSize.Level1)
404 {
405 MessageParcel data;
406 data.WriteBool(true);
407 data.WriteString("subscriberId");
408 MessageParcel reply;
409 MessageOption option;
410 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES), data,
411 reply, option);
412 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
413 }
414
415 /**
416 * @tc.name: OnSetBackgroundPolicyTest001
417 * @tc.desc: Test NetPolicyServiceStub OnSetBackgroundPolicy.
418 * @tc.type: FUNC
419 */
420 HWTEST_F(NetPolicyServiceStubTest, OnSetBackgroundPolicyTest001, TestSize.Level1)
421 {
422 MessageParcel data;
423 data.WriteBool(true);
424 data.WriteBool(true);
425 MessageParcel reply;
426 MessageOption option;
427 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY),
428 data, reply, option);
429 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
430 }
431
432 /**
433 * @tc.name: OnGetBackgroundPolicyTest001
434 * @tc.desc: Test NetPolicyServiceStub OnGetBackgroundPolicy.
435 * @tc.type: FUNC
436 */
437 HWTEST_F(NetPolicyServiceStubTest, OnGetBackgroundPolicyTest001, TestSize.Level1)
438 {
439 MessageParcel data;
440 data.WriteBool(true);
441 MessageParcel reply;
442 MessageOption option;
443 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY),
444 data, reply, option);
445 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
446 }
447
448 /**
449 * @tc.name: OnGetBackgroundPolicyByUidTest001
450 * @tc.desc: Test NetPolicyServiceStub OnGetBackgroundPolicyByUid.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(NetPolicyServiceStubTest, OnGetBackgroundPolicyByUidTest001, TestSize.Level1)
454 {
455 MessageParcel data;
456 data.WriteBool(true);
457 data.WriteBool(true);
458 MessageParcel reply;
459 MessageOption option;
460 int32_t ret = instance_->OnRemoteRequest(
461 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID), data, reply, option);
462 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
463 }
464
465 /**
466 * @tc.name: OnSnoozePolicyTest001
467 * @tc.desc: Test NetPolicyServiceStub OnSnoozePolicy.
468 * @tc.type: FUNC
469 */
470 HWTEST_F(NetPolicyServiceStubTest, OnSnoozePolicyTest001, TestSize.Level1)
471 {
472 MessageParcel data;
473 data.WriteBool(true);
474 data.WriteInt32(0);
475 data.WriteString("simId");
476 data.WriteInt32(0);
477 MessageParcel reply;
478 MessageOption option;
479 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY),
480 data, reply, option);
481 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
482 }
483
484 /**
485 * @tc.name: OnSetDeviceIdleTrustlistTest003
486 * @tc.desc: Test NetPolicyServiceStub OnSetDeviceIdleTrustlist.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(NetPolicyServiceStubTest, OnSetDeviceIdleTrustlistTest003, TestSize.Level1)
490 {
491 MessageParcel data;
492 data.WriteBool(true);
493 std::vector<uint32_t> uids;
494 uids.emplace_back(TEST_UID);
495 data.WriteUInt32Vector(uids);
496 data.WriteBool(true);
497 MessageParcel reply;
498 MessageOption option;
499 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST),
500 data, reply, option);
501 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
502 }
503
504 /**
505 * @tc.name: OnGetDeviceIdleTrustlistTest001
506 * @tc.desc: Test NetPolicyServiceStub OnGetDeviceIdleTrustlist.
507 * @tc.type: FUNC
508 */
509 HWTEST_F(NetPolicyServiceStubTest, OnGetDeviceIdleTrustlistTest001, TestSize.Level1)
510 {
511 MessageParcel data;
512 data.WriteBool(true);
513 MessageParcel reply;
514 MessageOption option;
515 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST),
516 data, reply, option);
517 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
518 }
519
520 /**
521 * @tc.name: OnSetDeviceIdlePolicyTest001
522 * @tc.desc: Test NetPolicyServiceStub OnSetDeviceIdlePolicy.
523 * @tc.type: FUNC
524 */
525 HWTEST_F(NetPolicyServiceStubTest, OnSetDeviceIdlePolicyTest001, TestSize.Level1)
526 {
527 MessageParcel data;
528 data.WriteBool(true);
529 data.WriteBool(true);
530 MessageParcel reply;
531 MessageOption option;
532 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY),
533 data, reply, option);
534 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
535 }
536
537 /**
538 * @tc.name: OnGetPowerSaveTrustlistTest001
539 * @tc.desc: Test NetPolicyServiceStub OnGetPowerSaveTrustlist.
540 * @tc.type: FUNC
541 */
542 HWTEST_F(NetPolicyServiceStubTest, OnGetPowerSaveTrustlistTest001, TestSize.Level1)
543 {
544 MessageParcel data;
545 data.WriteBool(true);
546 MessageParcel reply;
547 MessageOption option;
548 int32_t ret = instance_->OnRemoteRequest(
549 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST), data, reply, option);
550 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
551 }
552
553 /**
554 * @tc.name: OnSetPowerSaveTrustlistTest001
555 * @tc.desc: Test NetPolicyServiceStub OnSetPowerSaveTrustlist.
556 * @tc.type: FUNC
557 */
558 HWTEST_F(NetPolicyServiceStubTest, OnSetPowerSaveTrustlistTest001, TestSize.Level1)
559 {
560 MessageParcel data;
561 data.WriteBool(true);
562 std::vector<uint32_t> uids;
563 uids.emplace_back(TEST_UID);
564 data.WriteUInt32Vector(uids);
565 data.WriteBool(true);
566 MessageParcel reply;
567 MessageOption option;
568 int32_t ret = instance_->OnRemoteRequest(
569 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST), data, reply, option);
570 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
571 }
572
573 /**
574 * @tc.name: OnFactoryResetPoliciesTest001
575 * @tc.desc: Test NetPolicyServiceStub OnFactoryResetPolicies.
576 * @tc.type: FUNC
577 */
578 HWTEST_F(NetPolicyServiceStubTest, OnFactoryResetPoliciesTest001, TestSize.Level1)
579 {
580 MessageParcel data;
581 data.WriteBool(true);
582 MessageParcel reply;
583 MessageOption option;
584 int32_t ret = instance_->OnRemoteRequest(
585 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_FACTORYRESET_POLICIES), data, reply, option);
586 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
587 }
588
589 /**
590 * @tc.name: OnSetNetworkAccessPolicyTest001
591 * @tc.desc: Test NetPolicyServiceStub OnSetNetworkAccessPolicy.
592 * @tc.type: FUNC
593 */
594 HWTEST_F(NetPolicyServiceStubTest, OnSetNetworkAccessPolicyTest001, TestSize.Level1)
595 {
596 MessageParcel data;
597 data.WriteBool(false);
598 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
599 return;
600 }
601 bool wifiBool = true;
602 bool cellularBool = true;
603 data.WriteUint32(TEST_UID);
604 data.WriteUint8(wifiBool);
605 data.WriteUint8(cellularBool);
606 data.WriteBool(true);
607 MessageParcel reply;
608 MessageOption option;
609 std::cout << TEST_UID << std::endl;
610 int32_t ret = instance_->OnRemoteRequest(
611 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY), data, reply, option);
612 uint32_t callingUid = 1099;
613 uint32_t setUID = 20020024;
614 NetworkAccessPolicy policy;
615 policy.wifiAllow = 0;
616 policy.cellularAllow = 1;
617 instance_->HandleStoreNetworkPolicy(setUID, policy, callingUid);
618 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
619 }
620
621 /**
622 * @tc.name: OnGetNetworkAccessPolicy001
623 * @tc.desc: Test NetPolicyServiceStub OnGetNetworkAccessPolicy.
624 * @tc.type: FUNC
625 */
626 HWTEST_F(NetPolicyServiceStubTest, OnGetNetworkAccessPolicy001, TestSize.Level1)
627 {
628 MessageParcel data;
629 uint32_t userId = 1;
630 data.WriteBool(false);
631 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
632 return;
633 }
634 data.WriteBool(true);
635 data.WriteInt32(TEST_UID);
636 data.WriteUint32(userId);
637 MessageParcel reply;
638 MessageOption option;
639 int32_t ret = instance_->OnRemoteRequest(
640 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY), data, reply, option);
641 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
642 }
643 } // namespace NetManagerStandard
644 } // namespace OHOS
645