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 "network_manager_proxy.h"
17
18 #include <gtest/gtest.h>
19 #include <system_ability_definition.h>
20
21 #include <string>
22 #include <vector>
23
24 #include "edm_sys_manager_mock.h"
25 #include "enterprise_device_mgr_stub_mock.h"
26 #include "iptables_utils.h"
27 #include "utils.h"
28
29 using namespace testing::ext;
30 using namespace testing;
31
32 namespace OHOS {
33 namespace EDM {
34 namespace TEST {
35 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
36 class NetworkManagerProxyTest : public testing::Test {
37 protected:
38 void SetUp() override;
39
40 void TearDown() override;
41
42 static void TearDownTestSuite(void);
43 std::shared_ptr<NetworkManagerProxy> networkManagerProxy = nullptr;
44 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
45 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
46 };
47
SetUp()48 void NetworkManagerProxyTest::SetUp()
49 {
50 networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
51 edmSysManager_ = std::make_shared<EdmSysManager>();
52 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
53 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
54 Utils::SetEdmServiceEnable();
55 }
56
TearDown()57 void NetworkManagerProxyTest::TearDown()
58 {
59 networkManagerProxy.reset();
60 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
61 object_ = nullptr;
62 Utils::SetEdmServiceDisable();
63 }
64
TearDownTestSuite()65 void NetworkManagerProxyTest::TearDownTestSuite()
66 {
67 ASSERT_FALSE(Utils::GetEdmServiceState());
68 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
69 }
70
71 /**
72 * @tc.name: TestGetAllNetworkInterfacesSuc
73 * @tc.desc: Test GetAllNetworkInterfaces func.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(NetworkManagerProxyTest, TestGetAllNetworkInterfacesSuc, TestSize.Level1)
77 {
78 AppExecFwk::ElementName admin;
79 admin.SetBundleName(ADMIN_PACKAGENAME);
80 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
81 .Times(1)
82 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeArrayStringSendRequestGetPolicy));
83 std::vector<std::string> networkInterfaces;
84 int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(admin, networkInterfaces);
85 ASSERT_TRUE(ret == ERR_OK);
86 ASSERT_TRUE(networkInterfaces.size() == 1);
87 ASSERT_TRUE(networkInterfaces[0] == RETURN_STRING);
88 }
89
90 /**
91 * @tc.name: TestGetAllNetworkInterfacesFail
92 * @tc.desc: Test GetAllNetworkInterfaces func.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(NetworkManagerProxyTest, TestGetAllNetworkInterfacesFail, TestSize.Level1)
96 {
97 Utils::SetEdmServiceDisable();
98 AppExecFwk::ElementName admin;
99 admin.SetBundleName(ADMIN_PACKAGENAME);
100 std::vector<std::string> networkInterfaces;
101 int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(admin, networkInterfaces);
102 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
103 }
104
105 /**
106 * @tc.name: TestGetIpOrMacAddressSuc
107 * @tc.desc: Test GetIpOrMacAddress func.
108 * @tc.type: FUNC
109 */
110 HWTEST_F(NetworkManagerProxyTest, TestGetIpOrMacAddressSuc, TestSize.Level1)
111 {
112 AppExecFwk::ElementName admin;
113 admin.SetBundleName(ADMIN_PACKAGENAME);
114 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
115 .Times(1)
116 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
117 std::string info;
118 int32_t ret = networkManagerProxy->GetIpOrMacAddress(admin, "eth0", EdmInterfaceCode::GET_MAC, info);
119 ASSERT_TRUE(ret == ERR_OK);
120 ASSERT_TRUE(info == RETURN_STRING);
121 }
122
123 /**
124 * @tc.name: TestGetIpOrMacAddressFail
125 * @tc.desc: Test GetIpOrMacAddress func.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(NetworkManagerProxyTest, TestGetIpOrMacAddressFail, TestSize.Level1)
129 {
130 Utils::SetEdmServiceDisable();
131 AppExecFwk::ElementName admin;
132 admin.SetBundleName(ADMIN_PACKAGENAME);
133 std::string info;
134 int32_t ret = networkManagerProxy->GetIpOrMacAddress(admin, "eth0", EdmInterfaceCode::GET_MAC, info);
135 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
136 }
137
138 /**
139 * @tc.name: TestIsNetworkInterfaceDisabledSuc
140 * @tc.desc: Test IsNetworkInterfaceDisabled func.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledSuc, TestSize.Level1)
144 {
145 AppExecFwk::ElementName admin;
146 admin.SetBundleName(ADMIN_PACKAGENAME);
147 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
148 .Times(1)
149 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
150 bool status = false;
151 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(admin, "eth0", status);
152 ASSERT_TRUE(ret == ERR_OK);
153 ASSERT_TRUE(status);
154 }
155
156 /**
157 * @tc.name: TestIsNetworkInterfaceDisabledFail
158 * @tc.desc: Test IsNetworkInterfaceDisabled func.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledFail, TestSize.Level1)
162 {
163 Utils::SetEdmServiceDisable();
164 AppExecFwk::ElementName admin;
165 admin.SetBundleName(ADMIN_PACKAGENAME);
166 bool status = false;
167 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(admin, "eth0", status);
168 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
169 ASSERT_FALSE(status);
170 }
171
172 /**
173 * @tc.name: TestIsNetworkInterfaceDisabledSuc_01
174 * @tc.desc: Test IsNetworkInterfaceDisabled func.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledSuc_01, TestSize.Level1)
178 {
179 AppExecFwk::ElementName admin;
180 admin.SetBundleName(ADMIN_PACKAGENAME);
181 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
182 .Times(1)
183 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetPolicy));
184 bool status = false;
185 std::string networkInterface = "eth0";
186 MessageParcel data;
187 data.WriteInt32(HAS_ADMIN);
188 data.WriteParcelable(&admin);
189 data.WriteString(networkInterface);
190 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(data, status);
191 ASSERT_TRUE(ret == ERR_OK);
192 ASSERT_TRUE(status);
193 }
194
195 /**
196 * @tc.name: TestIsNetworkInterfaceDisabledFail_01
197 * @tc.desc: Test IsNetworkInterfaceDisabled func.
198 * @tc.type: FUNC
199 */
200 HWTEST_F(NetworkManagerProxyTest, TestIsNetworkInterfaceDisabledFail_01, TestSize.Level1)
201 {
202 Utils::SetEdmServiceDisable();
203 AppExecFwk::ElementName admin;
204 admin.SetBundleName(ADMIN_PACKAGENAME);
205 bool status = false;
206 std::string networkInterface = "eth0";
207 MessageParcel data;
208 data.WriteInt32(HAS_ADMIN);
209 data.WriteParcelable(&admin);
210 data.WriteString(networkInterface);
211 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(data, status);
212 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
213 ASSERT_FALSE(status);
214 }
215
216 /**
217 * @tc.name: TestSetNetworkInterfaceDisabledSuc
218 * @tc.desc: Test SetNetworkInterfaceDisabled func.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledSuc, TestSize.Level1)
222 {
223 AppExecFwk::ElementName admin;
224 admin.SetBundleName(ADMIN_PACKAGENAME);
225 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
226 .Times(1)
227 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
228 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
229 ASSERT_TRUE(ret == ERR_OK);
230 }
231
232 /**
233 * @tc.name: TestSetNetworkInterfaceDisabledFail
234 * @tc.desc: Test SetNetworkInterfaceDisabled func.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(NetworkManagerProxyTest, TestSetNetworkInterfaceDisabledFail, TestSize.Level1)
238 {
239 Utils::SetEdmServiceDisable();
240 AppExecFwk::ElementName admin;
241 admin.SetBundleName(ADMIN_PACKAGENAME);
242 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(admin, "eth0", true);
243 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
244 }
245
246 /**
247 * @tc.name: TestAddIptablesFilterRuleSuc
248 * @tc.desc: Test AddIptablesFilterRule func.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleSuc, TestSize.Level1)
252 {
253 AppExecFwk::ElementName admin;
254 admin.SetBundleName(ADMIN_PACKAGENAME);
255 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
256 .Times(1)
257 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
258 IPTABLES::AddFilter addFilter;
259 MessageParcel data;
260 data.WriteParcelable(&admin);
261 IPTABLES::IptablesUtils::WriteAddFilterConfig(addFilter, data);
262 int32_t ret = networkManagerProxy->AddIptablesFilterRule(data);
263 ASSERT_TRUE(ret == ERR_OK);
264 }
265
266 /**
267 * @tc.name: TestAddIptablesFilterRuleFail
268 * @tc.desc: Test AddIptablesFilterRule func.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(NetworkManagerProxyTest, TestAddIptablesFilterRuleFail, TestSize.Level1)
272 {
273 Utils::SetEdmServiceDisable();
274 AppExecFwk::ElementName admin;
275 admin.SetBundleName(ADMIN_PACKAGENAME);
276 IPTABLES::AddFilter addFilter;
277 MessageParcel data;
278 data.WriteParcelable(&admin);
279 IPTABLES::IptablesUtils::WriteAddFilterConfig(addFilter, data);
280 int32_t ret = networkManagerProxy->AddIptablesFilterRule(data);
281 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
282 }
283
284 /**
285 * @tc.name: TestRemoveIptablesFilterRuleSuc
286 * @tc.desc: Test RemoveIptablesFilterRule func.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleSuc, TestSize.Level1)
290 {
291 AppExecFwk::ElementName admin;
292 admin.SetBundleName(ADMIN_PACKAGENAME);
293 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
294 .Times(1)
295 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
296 IPTABLES::RemoveFilter removeFilter;
297 MessageParcel data;
298 data.WriteParcelable(&admin);
299 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(removeFilter, data);
300 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(data);
301 ASSERT_TRUE(ret == ERR_OK);
302 }
303
304 /**
305 * @tc.name: TestRemoveIptablesFilterRuleFail
306 * @tc.desc: Test RemoveIptablesFilterRule func.
307 * @tc.type: FUNC
308 */
309 HWTEST_F(NetworkManagerProxyTest, TestRemoveIptablesFilterRuleFail, TestSize.Level1)
310 {
311 Utils::SetEdmServiceDisable();
312 AppExecFwk::ElementName admin;
313 admin.SetBundleName(ADMIN_PACKAGENAME);
314 IPTABLES::RemoveFilter removeFilter;
315 MessageParcel data;
316 data.WriteParcelable(&admin);
317 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(removeFilter, data);
318 int32_t ret = networkManagerProxy->RemoveIptablesFilterRule(data);
319 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
320 }
321
322 /**
323 * @tc.name: TestListIptablesFilterRulesSuc
324 * @tc.desc: Test ListIptablesFilterRules func.
325 * @tc.type: FUNC
326 */
327 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesSuc, TestSize.Level1)
328 {
329 AppExecFwk::ElementName admin;
330 admin.SetBundleName(ADMIN_PACKAGENAME);
331 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
332 .Times(1)
333 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
334 std::string result;
335 MessageParcel data;
336 data.WriteInt32(HAS_ADMIN);
337 data.WriteParcelable(&admin);
338 int32_t ret = networkManagerProxy->ListIptablesFilterRules(data, result);
339 ASSERT_TRUE(ret == ERR_OK);
340 }
341
342 /**
343 * @tc.name: TestListIptablesFilterRulesFail
344 * @tc.desc: Test ListIptablesFilterRules func.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(NetworkManagerProxyTest, TestListIptablesFilterRulesFail, TestSize.Level1)
348 {
349 Utils::SetEdmServiceDisable();
350 AppExecFwk::ElementName admin;
351 admin.SetBundleName(ADMIN_PACKAGENAME);
352 std::string result;
353 MessageParcel data;
354 data.WriteInt32(HAS_ADMIN);
355 data.WriteParcelable(&admin);
356 int32_t ret = networkManagerProxy->ListIptablesFilterRules(data, result);
357 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
358 }
359
360 /**
361 * @tc.name: TestSetGlobalHttpProxySuc
362 * @tc.desc: Test SetGlobalHttpProxy func.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxySuc, TestSize.Level1)
366 {
367 AppExecFwk::ElementName admin;
368 admin.SetBundleName(ADMIN_PACKAGENAME);
369 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
370 .Times(1)
371 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
372 OHOS::NetManagerStandard::HttpProxy httpProxy;
373 httpProxy.SetHost("baidu.com");
374 httpProxy.SetPort(1234);
375 std::list<std::string> list = {"192.168.1.100"};
376 httpProxy.SetExclusionList(list);
377 MessageParcel data;
378 data.WriteParcelable(&admin);
379 bool retBool = httpProxy.Marshalling(data);
380 ASSERT_TRUE(retBool);
381 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(data);
382 ASSERT_TRUE(ret == ERR_OK);
383 }
384
385 /**
386 * @tc.name: TestSetGlobalHttpProxyFail
387 * @tc.desc: Test SetGlobalHttpProxy func.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(NetworkManagerProxyTest, TestSetGlobalHttpProxyFail, TestSize.Level1)
391 {
392 Utils::SetEdmServiceDisable();
393 AppExecFwk::ElementName admin;
394 admin.SetBundleName(ADMIN_PACKAGENAME);
395 OHOS::NetManagerStandard::HttpProxy httpProxy;
396 httpProxy.SetHost("baidu.com");
397 httpProxy.SetPort(1234);
398 std::list<std::string> list = {"192.168.1.100"};
399 httpProxy.SetExclusionList(list);
400 MessageParcel data;
401 data.WriteParcelable(&admin);
402 bool retBool = httpProxy.Marshalling(data);
403 ASSERT_TRUE(retBool);
404 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(data);
405 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
406 }
407
408 /**
409 * @tc.name: TestGetGlobalHttpProxySuc
410 * @tc.desc: Test GetGlobalHttpProxy func.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxySuc, TestSize.Level1)
414 {
415 AppExecFwk::ElementName admin;
416 admin.SetBundleName(ADMIN_PACKAGENAME);
417 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
418 .Times(1)
419 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeHttpProxySendRequestGetPolicy));
420 NetManagerStandard::HttpProxy httpProxy;
421 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
422 ASSERT_TRUE(ret == ERR_OK);
423 }
424
425 /**
426 * @tc.name: TestGetGlobalHttpProxyFail
427 * @tc.desc: Test GetGlobalHttpProxy func.
428 * @tc.type: FUNC
429 */
430 HWTEST_F(NetworkManagerProxyTest, TestGetGlobalHttpProxyFail, TestSize.Level1)
431 {
432 Utils::SetEdmServiceDisable();
433 AppExecFwk::ElementName admin;
434 admin.SetBundleName(ADMIN_PACKAGENAME);
435 NetManagerStandard::HttpProxy httpProxy;
436 int32_t ret = networkManagerProxy->GetGlobalHttpProxy(&admin, httpProxy);
437 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
438 }
439
440 /**
441 * @tc.name: TestAddFirewallRuleSuc
442 * @tc.desc: Test AddFirewallRule func.
443 * @tc.type: FUNC
444 */
445 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleSuc, TestSize.Level1)
446 {
447 AppExecFwk::ElementName admin;
448 admin.SetBundleName(ADMIN_PACKAGENAME);
449 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
450 .Times(1)
451 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
452 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
453 "", "", "", "", ""};
454 MessageParcel data;
455 data.WriteParcelable(&admin);
456 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
457 bool retBool = firewallRuleParcel.Marshalling(data);
458 ASSERT_TRUE(retBool);
459 int32_t ret = networkManagerProxy->AddFirewallRule(data);
460 ASSERT_TRUE(ret == ERR_OK);
461 }
462
463 /**
464 * @tc.name: TestAddFirewallRuleFail
465 * @tc.desc: Test AddFirewallRule func.
466 * @tc.type: FUNC
467 */
468 HWTEST_F(NetworkManagerProxyTest, TestAddFirewallRuleFail, TestSize.Level1)
469 {
470 Utils::SetEdmServiceDisable();
471 AppExecFwk::ElementName admin;
472 admin.SetBundleName(ADMIN_PACKAGENAME);
473 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
474 "", "", "", "", ""};
475 MessageParcel data;
476 data.WriteParcelable(&admin);
477 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
478 bool retBool = firewallRuleParcel.Marshalling(data);
479 ASSERT_TRUE(retBool);
480 int32_t ret = networkManagerProxy->AddFirewallRule(data);
481 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
482 }
483
484 /**
485 * @tc.name: TestRemoveFirewallRuleSuc
486 * @tc.desc: Test RemoveFirewallRule func.
487 * @tc.type: FUNC
488 */
489 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleSuc, TestSize.Level1)
490 {
491 AppExecFwk::ElementName admin;
492 admin.SetBundleName(ADMIN_PACKAGENAME);
493 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
494 .Times(1)
495 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
496 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
497 "", "", "", "", ""};
498 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
499 ASSERT_TRUE(ret == ERR_OK);
500 }
501
502 /**
503 * @tc.name: TestRemoveFirewallRuleFail
504 * @tc.desc: Test RemoveFirewallRule func.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(NetworkManagerProxyTest, TestRemoveFirewallRuleFail, TestSize.Level1)
508 {
509 Utils::SetEdmServiceDisable();
510 AppExecFwk::ElementName admin;
511 admin.SetBundleName(ADMIN_PACKAGENAME);
512 IPTABLES::FirewallRule rule{IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID, IPTABLES::Protocol::INVALID,
513 "", "", "", "", ""};
514 int32_t ret = networkManagerProxy->RemoveFirewallRule(admin, rule);
515 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
516 }
517
518 /**
519 * @tc.name: TestGetFirewallRulesSuc
520 * @tc.desc: Test GetFirewallRules func.
521 * @tc.type: FUNC
522 */
523 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesSuc, TestSize.Level1)
524 {
525 AppExecFwk::ElementName admin;
526 admin.SetBundleName(ADMIN_PACKAGENAME);
527
528 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
529 .Times(1)
530 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeBoolSendRequestGetFirewallRule));
531 std::vector<IPTABLES::FirewallRule> result;
532 MessageParcel data;
533 data.WriteInt32(HAS_ADMIN);
534 data.WriteParcelable(&admin);
535 int32_t ret = networkManagerProxy->GetFirewallRules(data, result);
536 ASSERT_TRUE(ret == ERR_OK);
537 ASSERT_TRUE(result.size() == 1);
538 }
539
540 /**
541 * @tc.name: TestGetFirewallRulesFail
542 * @tc.desc: Test GetFirewallRules func.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(NetworkManagerProxyTest, TestGetFirewallRulesFail, TestSize.Level1)
546 {
547 Utils::SetEdmServiceDisable();
548 AppExecFwk::ElementName admin;
549 admin.SetBundleName(ADMIN_PACKAGENAME);
550 std::vector<IPTABLES::FirewallRule> result;
551 MessageParcel data;
552 data.WriteInt32(HAS_ADMIN);
553 data.WriteParcelable(&admin);
554 int32_t ret = networkManagerProxy->GetFirewallRules(data, result);
555 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
556 }
557
558 /**
559 * @tc.name: TestAddDomainFilterRuleSuc
560 * @tc.desc: Test AddDomainFilterRule func.
561 * @tc.type: FUNC
562 */
563 HWTEST_F(NetworkManagerProxyTest, TestAddDomainFilterRuleSuc, TestSize.Level1)
564 {
565 AppExecFwk::ElementName admin;
566 admin.SetBundleName(ADMIN_PACKAGENAME);
567 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
568 .Times(1)
569 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
570 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
571 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
572 MessageParcel data;
573 data.WriteParcelable(&admin);
574 bool retBool = domainFilterRuleParcel.Marshalling(data);
575 ASSERT_TRUE(retBool);
576 int32_t ret = networkManagerProxy->AddDomainFilterRule(data);
577 ASSERT_TRUE(ret == ERR_OK);
578 }
579
580 /**
581 * @tc.name: TestAddDomainFilterRuleFail
582 * @tc.desc: Test AddDomainFilterRule func.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(NetworkManagerProxyTest, TestAddDomainFilterRuleFail, TestSize.Level1)
586 {
587 Utils::SetEdmServiceDisable();
588 AppExecFwk::ElementName admin;
589 admin.SetBundleName(ADMIN_PACKAGENAME);
590 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
591 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
592 MessageParcel data;
593 data.WriteParcelable(&admin);
594 bool retBool = domainFilterRuleParcel.Marshalling(data);
595 ASSERT_TRUE(retBool);
596 int32_t ret = networkManagerProxy->AddDomainFilterRule(data);
597 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
598 }
599
600 /**
601 * @tc.name: TestRemoveDomainFilterRuleSuc
602 * @tc.desc: Test RemoveDomainFilterRule func.
603 * @tc.type: FUNC
604 */
605 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleSuc, TestSize.Level1)
606 {
607 AppExecFwk::ElementName admin;
608 admin.SetBundleName(ADMIN_PACKAGENAME);
609 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
610 .Times(1)
611 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
612 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
613 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
614 ASSERT_TRUE(ret == ERR_OK);
615 }
616
617 /**
618 * @tc.name: TestRemoveDomainFilterRuleFail
619 * @tc.desc: Test RemoveDomainFilterRule func.
620 * @tc.type: FUNC
621 */
622 HWTEST_F(NetworkManagerProxyTest, TestRemoveDomainFilterRuleFail, TestSize.Level1)
623 {
624 Utils::SetEdmServiceDisable();
625 AppExecFwk::ElementName admin;
626 admin.SetBundleName(ADMIN_PACKAGENAME);
627 IPTABLES::DomainFilterRule rule{IPTABLES::Action::INVALID, "321", "www.example.com", IPTABLES::Direction::OUTPUT};
628 int32_t ret = networkManagerProxy->RemoveDomainFilterRule(admin, rule);
629 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
630 }
631
632 /**
633 * @tc.name: TestGetDomainFilterRulesSuc
634 * @tc.desc: Test GetDomainFilterRules func.
635 * @tc.type: FUNC
636 */
637 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesSuc, TestSize.Level1)
638 {
639 AppExecFwk::ElementName admin;
640 admin.SetBundleName(ADMIN_PACKAGENAME);
641
642 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
643 .Times(1)
644 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetDomainFilterRules));
645 std::vector<IPTABLES::DomainFilterRule> result;
646 MessageParcel data;
647 data.WriteInt32(HAS_ADMIN);
648 data.WriteParcelable(&admin);
649 int32_t ret = networkManagerProxy->GetDomainFilterRules(data, result);
650 ASSERT_TRUE(ret == ERR_OK);
651 ASSERT_TRUE(result.size() == 1);
652 }
653
654 /**
655 * @tc.name: TestGetDomainFilterRulesFail
656 * @tc.desc: Test GetDomainFilterRules func.
657 * @tc.type: FUNC
658 */
659 HWTEST_F(NetworkManagerProxyTest, TestGetDomainFilterRulesFail, TestSize.Level1)
660 {
661 Utils::SetEdmServiceDisable();
662 AppExecFwk::ElementName admin;
663 admin.SetBundleName(ADMIN_PACKAGENAME);
664 std::vector<IPTABLES::DomainFilterRule> result;
665 MessageParcel data;
666 data.WriteInt32(HAS_ADMIN);
667 data.WriteParcelable(&admin);
668 int32_t ret = networkManagerProxy->GetDomainFilterRules(data, result);
669 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
670 }
671
672 /**
673 * @tc.name: TestForceTurnOnMobileDataSuc
674 * @tc.desc: Test TurnOnMobileData func.
675 * @tc.type: FUNC
676 */
677 HWTEST_F(NetworkManagerProxyTest, TestForceTurnOnMobileDataSuc, TestSize.Level1)
678 {
679 MessageParcel data;
680 OHOS::AppExecFwk::ElementName admin;
681 admin.SetBundleName(ADMIN_PACKAGENAME);
682 data.WriteParcelable(&admin);
683 data.WriteBool(true);
684 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
685 .Times(1)
686 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
687
688 int32_t ret = networkManagerProxy->TurnOnMobileData(data);
689 ASSERT_TRUE(ret == ERR_OK);
690 }
691
692 /**
693 * @tc.name: TestForceTurnOnMobileDataFail
694 * @tc.desc: Test TurnOnMobileData func without enable edm service.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(NetworkManagerProxyTest, TestForceTurnOnMobileDataFail, TestSize.Level1)
698 {
699 Utils::SetEdmServiceDisable();
700 MessageParcel data;
701 OHOS::AppExecFwk::ElementName admin;
702 admin.SetBundleName(ADMIN_PACKAGENAME);
703 data.WriteParcelable(&admin);
704 data.WriteBool(true);
705 int32_t ret = networkManagerProxy->TurnOnMobileData(data);
706 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
707 }
708
709 /**
710 * @tc.name: TestTurnOnMobileDataSuc
711 * @tc.desc: Test TurnOnMobileData func.
712 * @tc.type: FUNC
713 */
714 HWTEST_F(NetworkManagerProxyTest, TestTurnOnMobileDataSuc, TestSize.Level1)
715 {
716 MessageParcel data;
717 OHOS::AppExecFwk::ElementName admin;
718 admin.SetBundleName(ADMIN_PACKAGENAME);
719 data.WriteParcelable(&admin);
720 data.WriteBool(false);
721 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
722 .Times(1)
723 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
724
725 int32_t ret = networkManagerProxy->TurnOnMobileData(data);
726 ASSERT_TRUE(ret == ERR_OK);
727 }
728
729 /**
730 * @tc.name: TestTurnOnMobileDataFail
731 * @tc.desc: Test TurnOnMobileData func without enable edm service.
732 * @tc.type: FUNC
733 */
734 HWTEST_F(NetworkManagerProxyTest, TestTurnOnMobileDataFail, TestSize.Level1)
735 {
736 Utils::SetEdmServiceDisable();
737 MessageParcel data;
738 OHOS::AppExecFwk::ElementName admin;
739 admin.SetBundleName(ADMIN_PACKAGENAME);
740 data.WriteParcelable(&admin);
741 data.WriteBool(false);
742 int32_t ret = networkManagerProxy->TurnOnMobileData(data);
743 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
744 }
745
746 /**
747 * @tc.name: TestTurnOffMobileDataSuc
748 * @tc.desc: Test TurnOffMobileData func.
749 * @tc.type: FUNC
750 */
751 HWTEST_F(NetworkManagerProxyTest, TestTurnOffMobileDataSuc, TestSize.Level1)
752 {
753 MessageParcel data;
754 OHOS::AppExecFwk::ElementName admin;
755 admin.SetBundleName(ADMIN_PACKAGENAME);
756 data.WriteParcelable(&admin);
757 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
758 .Times(1)
759 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
760
761 int32_t ret = networkManagerProxy->TurnOffMobileData(data);
762 ASSERT_TRUE(ret == ERR_OK);
763 }
764
765 /**
766 * @tc.name: TestTurnOffMobileDataFail
767 * @tc.desc: Test TurnOffMobileData func without enable edm service.
768 * @tc.type: FUNC
769 */
770 HWTEST_F(NetworkManagerProxyTest, TestTurnOffMobileDataFail, TestSize.Level1)
771 {
772 Utils::SetEdmServiceDisable();
773 MessageParcel data;
774 OHOS::AppExecFwk::ElementName admin;
775 admin.SetBundleName(ADMIN_PACKAGENAME);
776 data.WriteParcelable(&admin);
777 int32_t ret = networkManagerProxy->TurnOffMobileData(data);
778 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
779 }
780
781 /**
782 * @tc.name: TestAddApnSuc
783 * @tc.desc: Test AddApn func.
784 * @tc.type: FUNC
785 */
786 HWTEST_F(NetworkManagerProxyTest, TestAddApnSuc, TestSize.Level1)
787 {
788 OHOS::AppExecFwk::ElementName admin;
789 admin.SetBundleName(ADMIN_PACKAGENAME);
790 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
791 .Times(1)
792 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
793 std::map<std::string, std::string> apnInfoMap;
794 ApnPassword apnPassword;
795 int32_t ret = networkManagerProxy->AddApn(admin, apnInfoMap, apnPassword);
796 ASSERT_TRUE(ret == ERR_OK);
797 }
798
799 /**
800 * @tc.name: TestAddApnFail
801 * @tc.desc: Test AddApn func without enable edm service.
802 * @tc.type: FUNC
803 */
804 HWTEST_F(NetworkManagerProxyTest, TestAddApnFail, TestSize.Level1)
805 {
806 Utils::SetEdmServiceDisable();
807 OHOS::AppExecFwk::ElementName admin;
808 admin.SetBundleName(ADMIN_PACKAGENAME);
809 std::map<std::string, std::string> apnInfoMap;
810 ApnPassword apnPassword;
811 int32_t ret = networkManagerProxy->AddApn(admin, apnInfoMap, apnPassword);
812 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
813 }
814
815 /**
816 * @tc.name: TestUpdateApnSuc
817 * @tc.desc: Test UpdateApn func.
818 * @tc.type: FUNC
819 */
820 HWTEST_F(NetworkManagerProxyTest, TestUpdateApnSuc, TestSize.Level1)
821 {
822 OHOS::AppExecFwk::ElementName admin;
823 admin.SetBundleName(ADMIN_PACKAGENAME);
824 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
825 .Times(1)
826 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
827 std::map<std::string, std::string> apnInfoMap;
828 ApnPassword apnPassword;
829 int32_t ret = networkManagerProxy->UpdateApn(admin, apnInfoMap, "0", apnPassword);
830 ASSERT_TRUE(ret == ERR_OK);
831 }
832
833 /**
834 * @tc.name: TestUpdateApnFail
835 * @tc.desc: Test UpdateApn func without enable edm service.
836 * @tc.type: FUNC
837 */
838 HWTEST_F(NetworkManagerProxyTest, TestUpdateApnFail, TestSize.Level1)
839 {
840 Utils::SetEdmServiceDisable();
841 OHOS::AppExecFwk::ElementName admin;
842 admin.SetBundleName(ADMIN_PACKAGENAME);
843 std::map<std::string, std::string> apnInfoMap;
844 ApnPassword apnPassword;
845 int32_t ret = networkManagerProxy->UpdateApn(admin, apnInfoMap, "0", apnPassword);
846 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
847 }
848
849 /**
850 * @tc.name: TestDeleteApnSuc
851 * @tc.desc: Test DeleteApn func.
852 * @tc.type: FUNC
853 */
854 HWTEST_F(NetworkManagerProxyTest, TestDeleteApnSuc, TestSize.Level1)
855 {
856 MessageParcel data;
857 OHOS::AppExecFwk::ElementName admin;
858 admin.SetBundleName(ADMIN_PACKAGENAME);
859 data.WriteParcelable(&admin);
860 data.WriteString("0");
861 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
862 .Times(1)
863 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
864 int32_t ret = networkManagerProxy->DeleteApn(data);
865 ASSERT_TRUE(ret == ERR_OK);
866 }
867
868 /**
869 * @tc.name: TestDeleteApnFail
870 * @tc.desc: Test DeleteApn func without enable edm service.
871 * @tc.type: FUNC
872 */
873 HWTEST_F(NetworkManagerProxyTest, TestDeleteApnFail, TestSize.Level1)
874 {
875 Utils::SetEdmServiceDisable();
876 MessageParcel data;
877 OHOS::AppExecFwk::ElementName admin;
878 admin.SetBundleName(ADMIN_PACKAGENAME);
879 data.WriteParcelable(&admin);
880 data.WriteString("0");
881 int32_t ret = networkManagerProxy->DeleteApn(data);
882 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
883 }
884
885 /**
886 * @tc.name: TestSetPreferApnSuc
887 * @tc.desc: Test SetPreferApn func.
888 * @tc.type: FUNC
889 */
890 HWTEST_F(NetworkManagerProxyTest, TestSetPreferApnSuc, TestSize.Level1)
891 {
892 OHOS::AppExecFwk::ElementName admin;
893 admin.SetBundleName(ADMIN_PACKAGENAME);
894 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
895 .Times(1)
896 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
897 int32_t ret = networkManagerProxy->SetPreferApn(admin, "0");
898 ASSERT_TRUE(ret == ERR_OK);
899 }
900
901 /**
902 * @tc.name: TestSetPreferApnFail
903 * @tc.desc: Test SetPreferApn func without enable edm service.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(NetworkManagerProxyTest, TestSetPreferApnFail, TestSize.Level1)
907 {
908 Utils::SetEdmServiceDisable();
909 OHOS::AppExecFwk::ElementName admin;
910 admin.SetBundleName(ADMIN_PACKAGENAME);
911 int32_t ret = networkManagerProxy->SetPreferApn(admin, "0");
912 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
913 }
914
915 /**
916 * @tc.name: TestQueryApnSuc
917 * @tc.desc: Test QueryApn func.
918 * @tc.type: FUNC
919 */
920 HWTEST_F(NetworkManagerProxyTest, TestQueryApnSuc, TestSize.Level1)
921 {
922 OHOS::AppExecFwk::ElementName admin;
923 admin.SetBundleName(ADMIN_PACKAGENAME);
924 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
925 .Times(1)
926 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
927 std::map<std::string, std::string> apnInfoMap;
928 int32_t ret = networkManagerProxy->QueryApn(admin, "0", apnInfoMap);
929 ASSERT_TRUE(ret == ERR_OK);
930 }
931
932 /**
933 * @tc.name: TestQueryApnFail
934 * @tc.desc: Test QueryApn func without enable edm service.
935 * @tc.type: FUNC
936 */
937 HWTEST_F(NetworkManagerProxyTest, TestQueryApnFail, TestSize.Level1)
938 {
939 Utils::SetEdmServiceDisable();
940 OHOS::AppExecFwk::ElementName admin;
941 admin.SetBundleName(ADMIN_PACKAGENAME);
942 std::map<std::string, std::string> apnInfoMap;
943 int32_t ret = networkManagerProxy->QueryApn(admin, "0", apnInfoMap);
944 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
945 }
946
947 /**
948 * @tc.name: TestQueryApnSizeError
949 * @tc.desc: Test QueryApn func.
950 * @tc.type: FUNC
951 */
952 HWTEST_F(NetworkManagerProxyTest, TestQueryApnSizeError, TestSize.Level1)
953 {
954 OHOS::AppExecFwk::ElementName admin;
955 admin.SetBundleName(ADMIN_PACKAGENAME);
956 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
957 .Times(1)
958 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSizeError));
959 std::map<std::string, std::string> apnInfoMap;
960 int32_t ret = networkManagerProxy->QueryApn(admin, "0", apnInfoMap);
961 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
962 }
963
964 /**
965 * @tc.name: TestQueryApnIdsSuc
966 * @tc.desc: Test QueryApnIds func.
967 * @tc.type: FUNC
968 */
969 HWTEST_F(NetworkManagerProxyTest, TestQueryApnIdsSuc, TestSize.Level1)
970 {
971 OHOS::AppExecFwk::ElementName admin;
972 admin.SetBundleName(ADMIN_PACKAGENAME);
973 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
974 .Times(1)
975 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
976 std::map<std::string, std::string> apnInfoMap;
977 std::vector<std::string> apnIds;
978 int32_t ret = networkManagerProxy->QueryApnIds(admin, apnInfoMap, apnIds);
979 ASSERT_TRUE(ret == ERR_OK);
980 }
981
982 /**
983 * @tc.name: TestQueryApnIdsFail
984 * @tc.desc: Test QueryApnIds func without enable edm service.
985 * @tc.type: FUNC
986 */
987 HWTEST_F(NetworkManagerProxyTest, TestQueryApnIdsFail, TestSize.Level1)
988 {
989 Utils::SetEdmServiceDisable();
990 OHOS::AppExecFwk::ElementName admin;
991 admin.SetBundleName(ADMIN_PACKAGENAME);
992 std::map<std::string, std::string> apnInfoMap;
993 std::vector<std::string> apnIds;
994 int32_t ret = networkManagerProxy->QueryApnIds(admin, apnInfoMap, apnIds);
995 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
996 }
997
998 /**
999 * @tc.name: TestQueryApnIdsSizeError
1000 * @tc.desc: Test QueryApnIds func.
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(NetworkManagerProxyTest, TestQueryApnIdsSizeError, TestSize.Level1)
1004 {
1005 OHOS::AppExecFwk::ElementName admin;
1006 admin.SetBundleName(ADMIN_PACKAGENAME);
1007 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
1008 .Times(1)
1009 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSizeError));
1010 std::map<std::string, std::string> apnInfoMap;
1011 std::vector<std::string> apnIds;
1012 int32_t ret = networkManagerProxy->QueryApnIds(admin, apnInfoMap, apnIds);
1013 ASSERT_TRUE(ret == EdmReturnErrCode::SYSTEM_ABNORMALLY);
1014 }
1015
1016 } // namespace TEST
1017 } // namespace EDM
1018 } // namespace OHOS
1019