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 auto task = ffrtQueue_.submit_h([this, &data, &reply, &requestFunc, &result]() {
178 result = (this->*requestFunc)(data, reply);
179 }, ffrt::task_attr().name("FfrtOnRemoteRequest"));
180 ffrtQueue_.wait(task);
181 return result;
182 }
183 }
184
185 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
186 }
187
SetNicTrafficAllowed(const std::vector<std::string> & ifaceNames,bool status)188 int32_t SetNicTrafficAllowed(const std::vector<std::string> &ifaceNames, bool status) override
189 {
190 return 0;
191 }
192 };
193
194 } // namespace
195
196 using namespace testing::ext;
197 class NetPolicyServiceStubTest : public testing::Test {
198 public:
199 static void SetUpTestCase();
200 static void TearDownTestCase();
201 void SetUp();
202 void TearDown();
203
204 static inline sptr<NetPolicyServiceStub> instance_ = new (std::nothrow) MockNetPolicyServiceStubTest();
205 };
206
SetUpTestCase()207 void NetPolicyServiceStubTest::SetUpTestCase() {}
208
TearDownTestCase()209 void NetPolicyServiceStubTest::TearDownTestCase()
210 {
211 instance_ = nullptr;
212 }
213
SetUp()214 void NetPolicyServiceStubTest::SetUp() {}
215
TearDown()216 void NetPolicyServiceStubTest::TearDown() {}
217
218 /**
219 * @tc.name: OnRemoteRequestTest001
220 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest001, TestSize.Level1)
224 {
225 MessageParcel data;
226 MessageParcel reply;
227 MessageOption option;
228 data.WriteBool(false);
229 int32_t ret =
230 instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_END), data, reply, option);
231 EXPECT_EQ(ret, NETMANAGER_ERR_DESCRIPTOR_MISMATCH);
232 }
233
234 /**
235 * @tc.name: OnRemoteRequestTest002
236 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest002, TestSize.Level1)
240 {
241 MessageParcel data;
242 data.WriteBool(false);
243 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
244 return;
245 }
246 MessageParcel reply;
247 MessageOption option;
248 int32_t ret =
249 instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_END), data, reply, option);
250 EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
251 }
252
253 /**
254 * @tc.name: OnRemoteRequestTest003
255 * @tc.desc: Test NetPolicyServiceStub OnRemoteRequest.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(NetPolicyServiceStubTest, OnRemoteRequestTest003, TestSize.Level1)
259 {
260 MessageParcel data;
261 data.WriteBool(false);
262 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
263 return;
264 }
265 MessageParcel reply;
266 MessageOption option;
267 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID),
268 data, reply, option);
269 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
270
271 int32_t result = NETMANAGER_ERROR;
272 EXPECT_EQ(reply.ReadInt32(result), true);
273 EXPECT_EQ(result, NETMANAGER_ERR_PERMISSION_DENIED);
274 }
275
276 /**
277 * @tc.name: OnSetPolicyByUidTest001
278 * @tc.desc: Test NetPolicyServiceStub OnSetPolicyByUid.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(NetPolicyServiceStubTest, OnSetPolicyByUidTest001, TestSize.Level1)
282 {
283 MessageParcel data;
284 data.WriteBool(true);
285 data.WriteUint32(TEST_UID);
286 data.WriteUint32(0);
287 MessageParcel reply;
288 MessageOption option;
289 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID),
290 data, reply, option);
291 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
292 }
293
294 /**
295 * @tc.name: OnGetPolicyByUidTest001
296 * @tc.desc: Test NetPolicyServiceStub OnGetPolicyByUid.
297 * @tc.type: FUNC
298 */
299 HWTEST_F(NetPolicyServiceStubTest, OnGetPolicyByUidTest001, TestSize.Level1)
300 {
301 MessageParcel data;
302 data.WriteBool(true);
303 data.WriteUint32(TEST_UID);
304 MessageParcel reply;
305 MessageOption option;
306 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID),
307 data, reply, option);
308 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
309 }
310
311 /**
312 * @tc.name: OnGetUidsByPolicyTest001
313 * @tc.desc: Test NetPolicyServiceStub OnGetUidsByPolicy.
314 * @tc.type: FUNC
315 */
316 HWTEST_F(NetPolicyServiceStubTest, OnGetUidsByPolicyTest001, TestSize.Level1)
317 {
318 MessageParcel data;
319 data.WriteBool(true);
320 data.WriteUint32(TEST_UID);
321 MessageParcel reply;
322 MessageOption option;
323 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY),
324 data, reply, option);
325 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
326 }
327
328 /**
329 * @tc.name: OnIsUidNetAllowedMeteredTest001
330 * @tc.desc: Test NetPolicyServiceStub OnIsUidNetAllowedMetered.
331 * @tc.type: FUNC
332 */
333 HWTEST_F(NetPolicyServiceStubTest, OnIsUidNetAllowedMeteredTest001, TestSize.Level1)
334 {
335 MessageParcel data;
336 data.WriteBool(true);
337 data.WriteUint32(TEST_UID);
338 data.WriteBool(true);
339 MessageParcel reply;
340 MessageOption option;
341 int32_t ret = instance_->OnRemoteRequest(
342 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED), data, reply, option);
343 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
344 }
345
346 /**
347 * @tc.name: OnIsUidNetAllowedIfaceNameTest001
348 * @tc.desc: Test NetPolicyServiceStub OnIsUidNetAllowedIfaceName.
349 * @tc.type: FUNC
350 */
351 HWTEST_F(NetPolicyServiceStubTest, OnIsUidNetAllowedIfaceNameTest001, TestSize.Level1)
352 {
353 MessageParcel data;
354 data.WriteBool(true);
355 data.WriteUint32(TEST_UID);
356 data.WriteString(ETH_IFACE_NAME);
357 MessageParcel reply;
358 MessageOption option;
359 int32_t ret = instance_->OnRemoteRequest(
360 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE), data, reply, option);
361 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
362 }
363
364 /**
365 * @tc.name: OnSetNetQuotaPoliciesTest001
366 * @tc.desc: Test NetPolicyServiceStub OnSetNetQuotaPolicies.
367 * @tc.type: FUNC
368 */
369 HWTEST_F(NetPolicyServiceStubTest, OnSetNetQuotaPoliciesTest001, TestSize.Level1)
370 {
371 MessageParcel data;
372 data.WriteBool(true);
373 NetQuotaPolicy quotaPolicy;
374 quotaPolicy.quotapolicy.title = "test";
375 std::vector<NetQuotaPolicy> quotaPolicies;
376 quotaPolicies.emplace_back(quotaPolicy);
377 NetQuotaPolicy::Marshalling(data, quotaPolicies);
378 MessageParcel reply;
379 MessageOption option;
380 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES),
381 data, reply, option);
382 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
383 }
384
385 /**
386 * @tc.name: OnGetNetQuotaPoliciesTest001
387 * @tc.desc: Test NetPolicyServiceStub OnGetNetQuotaPolicies.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(NetPolicyServiceStubTest, OnGetNetQuotaPoliciesTest001, TestSize.Level1)
391 {
392 MessageParcel data;
393 data.WriteBool(true);
394 MessageParcel reply;
395 MessageOption option;
396 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES),
397 data, reply, option);
398 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
399 }
400
401 /**
402 * @tc.name: OnResetPoliciesTest001
403 * @tc.desc: Test NetPolicyServiceStub OnResetPolicies.
404 * @tc.type: FUNC
405 */
406 HWTEST_F(NetPolicyServiceStubTest, OnResetPoliciesTest001, TestSize.Level1)
407 {
408 MessageParcel data;
409 data.WriteBool(true);
410 data.WriteString("subscriberId");
411 MessageParcel reply;
412 MessageOption option;
413 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES), data,
414 reply, option);
415 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
416 }
417
418 /**
419 * @tc.name: OnSetBackgroundPolicyTest001
420 * @tc.desc: Test NetPolicyServiceStub OnSetBackgroundPolicy.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(NetPolicyServiceStubTest, OnSetBackgroundPolicyTest001, TestSize.Level1)
424 {
425 MessageParcel data;
426 data.WriteBool(true);
427 data.WriteBool(true);
428 MessageParcel reply;
429 MessageOption option;
430 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY),
431 data, reply, option);
432 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
433 }
434
435 /**
436 * @tc.name: OnGetBackgroundPolicyTest001
437 * @tc.desc: Test NetPolicyServiceStub OnGetBackgroundPolicy.
438 * @tc.type: FUNC
439 */
440 HWTEST_F(NetPolicyServiceStubTest, OnGetBackgroundPolicyTest001, TestSize.Level1)
441 {
442 MessageParcel data;
443 data.WriteBool(true);
444 MessageParcel reply;
445 MessageOption option;
446 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY),
447 data, reply, option);
448 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
449 }
450
451 /**
452 * @tc.name: OnGetBackgroundPolicyByUidTest001
453 * @tc.desc: Test NetPolicyServiceStub OnGetBackgroundPolicyByUid.
454 * @tc.type: FUNC
455 */
456 HWTEST_F(NetPolicyServiceStubTest, OnGetBackgroundPolicyByUidTest001, TestSize.Level1)
457 {
458 MessageParcel data;
459 data.WriteBool(true);
460 data.WriteBool(true);
461 MessageParcel reply;
462 MessageOption option;
463 int32_t ret = instance_->OnRemoteRequest(
464 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID), data, reply, option);
465 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
466 }
467
468 /**
469 * @tc.name: OnSnoozePolicyTest001
470 * @tc.desc: Test NetPolicyServiceStub OnSnoozePolicy.
471 * @tc.type: FUNC
472 */
473 HWTEST_F(NetPolicyServiceStubTest, OnSnoozePolicyTest001, TestSize.Level1)
474 {
475 MessageParcel data;
476 data.WriteBool(true);
477 data.WriteInt32(0);
478 data.WriteString("simId");
479 data.WriteInt32(0);
480 MessageParcel reply;
481 MessageOption option;
482 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY),
483 data, reply, option);
484 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
485 }
486
487 /**
488 * @tc.name: OnSetDeviceIdleTrustlistTest003
489 * @tc.desc: Test NetPolicyServiceStub OnSetDeviceIdleTrustlist.
490 * @tc.type: FUNC
491 */
492 HWTEST_F(NetPolicyServiceStubTest, OnSetDeviceIdleTrustlistTest003, TestSize.Level1)
493 {
494 MessageParcel data;
495 data.WriteBool(true);
496 std::vector<uint32_t> uids;
497 uids.emplace_back(TEST_UID);
498 data.WriteUInt32Vector(uids);
499 data.WriteBool(true);
500 MessageParcel reply;
501 MessageOption option;
502 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST),
503 data, reply, option);
504 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
505 }
506
507 /**
508 * @tc.name: OnGetDeviceIdleTrustlistTest001
509 * @tc.desc: Test NetPolicyServiceStub OnGetDeviceIdleTrustlist.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(NetPolicyServiceStubTest, OnGetDeviceIdleTrustlistTest001, TestSize.Level1)
513 {
514 MessageParcel data;
515 data.WriteBool(true);
516 MessageParcel reply;
517 MessageOption option;
518 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST),
519 data, reply, option);
520 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
521 }
522
523 /**
524 * @tc.name: OnSetDeviceIdlePolicyTest001
525 * @tc.desc: Test NetPolicyServiceStub OnSetDeviceIdlePolicy.
526 * @tc.type: FUNC
527 */
528 HWTEST_F(NetPolicyServiceStubTest, OnSetDeviceIdlePolicyTest001, TestSize.Level1)
529 {
530 MessageParcel data;
531 data.WriteBool(true);
532 data.WriteBool(true);
533 MessageParcel reply;
534 MessageOption option;
535 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY),
536 data, reply, option);
537 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
538 }
539
540 /**
541 * @tc.name: OnGetPowerSaveTrustlistTest001
542 * @tc.desc: Test NetPolicyServiceStub OnGetPowerSaveTrustlist.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(NetPolicyServiceStubTest, OnGetPowerSaveTrustlistTest001, TestSize.Level1)
546 {
547 MessageParcel data;
548 data.WriteBool(true);
549 MessageParcel reply;
550 MessageOption option;
551 int32_t ret = instance_->OnRemoteRequest(
552 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST), data, reply, option);
553 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
554 }
555
556 /**
557 * @tc.name: OnSetPowerSaveTrustlistTest001
558 * @tc.desc: Test NetPolicyServiceStub OnSetPowerSaveTrustlist.
559 * @tc.type: FUNC
560 */
561 HWTEST_F(NetPolicyServiceStubTest, OnSetPowerSaveTrustlistTest001, TestSize.Level1)
562 {
563 MessageParcel data;
564 data.WriteBool(true);
565 std::vector<uint32_t> uids;
566 uids.emplace_back(TEST_UID);
567 data.WriteUInt32Vector(uids);
568 data.WriteBool(true);
569 MessageParcel reply;
570 MessageOption option;
571 int32_t ret = instance_->OnRemoteRequest(
572 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST), data, reply, option);
573 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
574 }
575
576 /**
577 * @tc.name: OnFactoryResetPoliciesTest001
578 * @tc.desc: Test NetPolicyServiceStub OnFactoryResetPolicies.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(NetPolicyServiceStubTest, OnFactoryResetPoliciesTest001, TestSize.Level1)
582 {
583 MessageParcel data;
584 data.WriteBool(true);
585 MessageParcel reply;
586 MessageOption option;
587 int32_t ret = instance_->OnRemoteRequest(
588 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_FACTORYRESET_POLICIES), data, reply, option);
589 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
590 }
591
592 /**
593 * @tc.name: OnSetNetworkAccessPolicyTest001
594 * @tc.desc: Test NetPolicyServiceStub OnSetNetworkAccessPolicy.
595 * @tc.type: FUNC
596 */
597 HWTEST_F(NetPolicyServiceStubTest, OnSetNetworkAccessPolicyTest001, TestSize.Level1)
598 {
599 MessageParcel data;
600 data.WriteBool(false);
601 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
602 return;
603 }
604 bool wifiBool = true;
605 bool cellularBool = true;
606 data.WriteUint32(TEST_UID);
607 data.WriteUint8(wifiBool);
608 data.WriteUint8(cellularBool);
609 data.WriteBool(true);
610 MessageParcel reply;
611 MessageOption option;
612 std::cout << TEST_UID << std::endl;
613 int32_t ret = instance_->OnRemoteRequest(
614 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY), data, reply, option);
615 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
616 }
617
618 /**
619 * @tc.name: OnGetNetworkAccessPolicy001
620 * @tc.desc: Test NetPolicyServiceStub OnGetNetworkAccessPolicy.
621 * @tc.type: FUNC
622 */
623 HWTEST_F(NetPolicyServiceStubTest, OnGetNetworkAccessPolicy001, TestSize.Level1)
624 {
625 MessageParcel data;
626 uint32_t userId = 1;
627 data.WriteBool(false);
628 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
629 return;
630 }
631 data.WriteBool(true);
632 data.WriteInt32(TEST_UID);
633 data.WriteUint32(userId);
634 MessageParcel reply;
635 MessageOption option;
636 int32_t ret = instance_->OnRemoteRequest(
637 static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY), data, reply, option);
638 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
639 }
640 } // namespace NetManagerStandard
641 } // namespace OHOS
642