1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "common_net_conn_callback_test.h"
24 #include "net_conn_service_stub_test.h"
25 #include "net_interface_callback_stub.h"
26 #include "netmanager_base_test_security.h"
27 #include "net_conn_types.h"
28
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 constexpr bool TEST_BOOL_VALUE = false;
33 constexpr int32_t TEST_INT32_VALUE = 1;
34 constexpr uint32_t TEST_UINT32_VALUE = 1;
35 constexpr const char *TEST_STRING_VALUE = "test";
36 constexpr const char *TEST_DOMAIN = "test.com";
37 } // namespace
38
39 class INetFactoryResetCallbackTest : public IRemoteStub<INetFactoryResetCallback> {
40 public:
41 INetFactoryResetCallbackTest() = default;
42
OnNetFactoryReset()43 int32_t OnNetFactoryReset()
44 {
45 return 0;
46 }
47 };
48
49 using namespace testing::ext;
50 class NetConnServiceStubTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp();
55 void TearDown();
56 static inline std::shared_ptr<NetConnServiceStub> instance_ = std::make_shared<MockNetConnServiceStub>();
57 static inline sptr<INetSupplierCallback> supplierCallback_ = new (std::nothrow) NetSupplierCallbackStub();
58 static int32_t SendRemoteRequest(MessageParcel &data, ConnInterfaceCode code);
59 };
60
SetUpTestCase()61 void NetConnServiceStubTest::SetUpTestCase() {}
62
TearDownTestCase()63 void NetConnServiceStubTest::TearDownTestCase() {}
64
SetUp()65 void NetConnServiceStubTest::SetUp() {}
66
TearDown()67 void NetConnServiceStubTest::TearDown() {}
68
SendRemoteRequest(MessageParcel & data,ConnInterfaceCode code)69 int32_t NetConnServiceStubTest::SendRemoteRequest(MessageParcel &data, ConnInterfaceCode code)
70 {
71 MessageParcel reply;
72 MessageOption option;
73 return instance_->OnRemoteRequest(static_cast<uint32_t>(code), data, reply, option);
74 }
75
76 /**
77 * @tc.name: OnSystemReadyTest001
78 * @tc.desc: Test NetConnServiceStub OnSystemReady.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(NetConnServiceStubTest, OnSystemReadyTest001, TestSize.Level1)
82 {
83 MessageParcel data;
84 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
85 return;
86 }
87 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SYSTEM_READY);
88 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
89 }
90
91 /**
92 * @tc.name: OnRegisterNetSupplierTest001
93 * @tc.desc: Test NetConnServiceStub OnRegisterNetSupplier.
94 * @tc.type: FUNC
95 */
96 HWTEST_F(NetConnServiceStubTest, OnRegisterNetSupplierTest001, TestSize.Level1)
97 {
98 NetManagerBaseAccessToken token;
99 MessageParcel data;
100 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
101 return;
102 }
103 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
104 return;
105 }
106 if (!data.WriteString(TEST_STRING_VALUE)) {
107 return;
108 }
109 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
110 return;
111 }
112 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
113 return;
114 }
115 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REG_NET_SUPPLIER);
116 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
117 }
118
119 /**
120 * @tc.name: OnUnregisterNetSupplierTest001
121 * @tc.desc: Test NetConnServiceStub OnUnregisterNetSupplier.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(NetConnServiceStubTest, OnUnregisterNetSupplierTest001, TestSize.Level1)
125 {
126 NetManagerBaseAccessToken token;
127 MessageParcel data;
128 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
129 return;
130 }
131 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
132 return;
133 }
134 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_UNREG_NETWORK);
135 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
136 }
137
138 /**
139 * @tc.name: OnRegisterNetSupplierCallbackTest001
140 * @tc.desc: Test NetConnServiceStub OnRegisterNetSupplierCallback.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(NetConnServiceStubTest, OnRegisterNetSupplierCallbackTest001, TestSize.Level1)
144 {
145 NetManagerBaseAccessToken token;
146 MessageParcel data;
147 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
148 return;
149 }
150 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
151 return;
152 }
153 sptr<INetSupplierCallback> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
154 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
155 return;
156 }
157 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK);
158 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
159 }
160
161 /**
162 * @tc.name: OnRegisterNetConnCallbackTest001
163 * @tc.desc: Test NetConnServiceStub OnRegisterNetConnCallback.
164 * @tc.type: FUNC
165 */
166 HWTEST_F(NetConnServiceStubTest, OnRegisterNetConnCallbackTest001, TestSize.Level1)
167 {
168 NetManagerBaseAccessToken token;
169 MessageParcel data;
170 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
171 return;
172 }
173 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
174 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
175 return;
176 }
177 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK);
178 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
179 }
180
181 /**
182 * @tc.name: OnUnregisterNetConnCallbackTest001
183 * @tc.desc: Test NetConnServiceStub OnUnregisterNetConnCallback.
184 * @tc.type: FUNC
185 */
186 HWTEST_F(NetConnServiceStubTest, OnUnregisterNetConnCallbackTest001, TestSize.Level1)
187 {
188 NetManagerBaseAccessToken token;
189 MessageParcel data;
190 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
191 return;
192 }
193 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
194 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
195 return;
196 }
197 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK);
198 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
199 }
200
201 /**
202 * @tc.name: OnUpdateNetStateForTest001
203 * @tc.desc: Test NetConnServiceStub OnUpdateNetStateForTest.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(NetConnServiceStubTest, OnUpdateNetStateForTest001, TestSize.Level1)
207 {
208 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
209 if (netSpecifier == nullptr) {
210 return;
211 }
212 MessageParcel data;
213 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
214 return;
215 }
216 if (!netSpecifier->Marshalling(data)) {
217 return;
218 }
219 if (!data.WriteInt32(TEST_INT32_VALUE)) {
220 return;
221 }
222 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST);
223 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
224 }
225
226 /**
227 * @tc.name: OnUpdateNetSupplierInfoTest001
228 * @tc.desc: Test NetConnServiceStub OnUpdateNetSupplierInfo.
229 * @tc.type: FUNC
230 */
231 HWTEST_F(NetConnServiceStubTest, OnUpdateNetSupplierInfoTest001, TestSize.Level1)
232 {
233 NetManagerBaseAccessToken token;
234 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
235 if (netSupplierInfo == nullptr) {
236 return;
237 }
238 MessageParcel data;
239 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
240 return;
241 }
242 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
243 return;
244 }
245 if (!netSupplierInfo->Marshalling(data)) {
246 return;
247 }
248 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO);
249 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
250 }
251
252 /**
253 * @tc.name: OnUpdateNetLinkInfoTest001
254 * @tc.desc: Test NetConnServiceStub OnUpdateNetLinkInfo.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(NetConnServiceStubTest, OnUpdateNetLinkInfoTest001, TestSize.Level1)
258 {
259 NetManagerBaseAccessToken token;
260 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
261 if (netLinkInfo == nullptr) {
262 return;
263 }
264 MessageParcel data;
265 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
266 return;
267 }
268 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
269 return;
270 }
271 if (!netLinkInfo->Marshalling(data)) {
272 return;
273 }
274 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO);
275 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
276 }
277
278 /**
279 * @tc.name: OnNetDetectionTest001
280 * @tc.desc: Test NetConnServiceStub OnNetDetection.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(NetConnServiceStubTest, OnNetDetectionTest001, TestSize.Level1)
284 {
285 NetManagerBaseAccessToken token;
286 MessageParcel data;
287 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
288 return;
289 }
290 if (!data.WriteInt32(TEST_INT32_VALUE)) {
291 return;
292 }
293 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_NET_DETECTION);
294 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
295 }
296
297 /**
298 * @tc.name: OnGetIfaceNamesTest001
299 * @tc.desc: Test NetConnServiceStub OnGetIfaceNames.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(NetConnServiceStubTest, OnGetIfaceNamesTest001, TestSize.Level1)
303 {
304 MessageParcel data;
305 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
306 return;
307 }
308 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
309 return;
310 }
311 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES);
312 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
313 }
314
315 /**
316 * @tc.name: OnGetIfaceNameByTypeTest001
317 * @tc.desc: Test NetConnServiceStub OnGetIfaceNameByType.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(NetConnServiceStubTest, OnGetIfaceNameByTypeTest001, TestSize.Level1)
321 {
322 MessageParcel data;
323 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
324 return;
325 }
326 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
327 return;
328 }
329 if (!data.WriteString(TEST_STRING_VALUE)) {
330 return;
331 }
332 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE);
333 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
334 }
335
336 /**
337 * @tc.name: OnGetDefaultNetTest001
338 * @tc.desc: Test NetConnServiceStub OnGetDefaultNet.
339 * @tc.type: FUNC
340 */
341 HWTEST_F(NetConnServiceStubTest, OnGetDefaultNetTest001, TestSize.Level1)
342 {
343 NetManagerBaseAccessToken token;
344 MessageParcel data;
345 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
346 return;
347 }
348 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GETDEFAULTNETWORK);
349 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
350 }
351
352 /**
353 * @tc.name: OnHasDefaultNetTest001
354 * @tc.desc: Test NetConnServiceStub OnHasDefaultNet.
355 * @tc.type: FUNC
356 */
357 HWTEST_F(NetConnServiceStubTest, OnHasDefaultNetTest001, TestSize.Level1)
358 {
359 NetManagerBaseAccessToken token;
360 MessageParcel data;
361 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
362 return;
363 }
364 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_HASDEFAULTNET);
365 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
366 }
367
368 /**
369 * @tc.name: OnGetSpecificNetTest001
370 * @tc.desc: Test NetConnServiceStub OnGetSpecificNet.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(NetConnServiceStubTest, OnGetSpecificNetTest001, TestSize.Level1)
374 {
375 MessageParcel data;
376 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
377 return;
378 }
379 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
380 return;
381 }
382 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET);
383 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
384 }
385
386 /**
387 * @tc.name: OnGetAllNetsTest001
388 * @tc.desc: Test NetConnServiceStub OnGetAllNets.
389 * @tc.type: FUNC
390 */
391 HWTEST_F(NetConnServiceStubTest, OnGetAllNetsTest001, TestSize.Level1)
392 {
393 NetManagerBaseAccessToken token;
394 MessageParcel data;
395 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
396 return;
397 }
398 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_ALL_NETS);
399 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
400 }
401
402 /**
403 * @tc.name: OnGetSpecificUidNetTest001
404 * @tc.desc: Test NetConnServiceStub OnGetSpecificUidNet.
405 * @tc.type: FUNC
406 */
407 HWTEST_F(NetConnServiceStubTest, OnGetSpecificUidNetTest001, TestSize.Level1)
408 {
409 MessageParcel data;
410 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
411 return;
412 }
413 if (!data.WriteInt32(TEST_INT32_VALUE)) {
414 return;
415 }
416 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET);
417 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
418 }
419
420 /**
421 * @tc.name: OnGetConnectionPropertiesTest001
422 * @tc.desc: Test NetConnServiceStub OnGetConnectionProperties.
423 * @tc.type: FUNC
424 */
425 HWTEST_F(NetConnServiceStubTest, OnGetConnectionPropertiesTest001, TestSize.Level1)
426 {
427 NetManagerBaseAccessToken token;
428 MessageParcel data;
429 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
430 return;
431 }
432 if (!data.WriteInt32(TEST_INT32_VALUE)) {
433 return;
434 }
435 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES);
436 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
437 }
438
439 /**
440 * @tc.name: OnGetNetCapabilitiesTest001
441 * @tc.desc: Test NetConnServiceStub OnGetNetCapabilities.
442 * @tc.type: FUNC
443 */
444 HWTEST_F(NetConnServiceStubTest, OnGetNetCapabilitiesTest001, TestSize.Level1)
445 {
446 NetManagerBaseAccessToken token;
447 MessageParcel data;
448 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
449 return;
450 }
451 if (!data.WriteInt32(TEST_INT32_VALUE)) {
452 return;
453 }
454 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES);
455 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
456 }
457
458 /**
459 * @tc.name: OnGetAddressesByNameTest001
460 * @tc.desc: Test NetConnServiceStub OnGetAddressesByName.
461 * @tc.type: FUNC
462 */
463 HWTEST_F(NetConnServiceStubTest, OnGetAddressesByNameTest001, TestSize.Level1)
464 {
465 NetManagerBaseAccessToken token;
466 MessageParcel data;
467 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
468 return;
469 }
470 if (!data.WriteString(TEST_STRING_VALUE)) {
471 return;
472 }
473 if (!data.WriteInt32(TEST_INT32_VALUE)) {
474 return;
475 }
476 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME);
477 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
478 }
479
480 /**
481 * @tc.name: OnGetAddressByNameTest001
482 * @tc.desc: Test NetConnServiceStub OnGetAddressByName.
483 * @tc.type: FUNC
484 */
485 HWTEST_F(NetConnServiceStubTest, OnGetAddressByNameTest001, TestSize.Level1)
486 {
487 NetManagerBaseAccessToken token;
488 MessageParcel data;
489 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
490 return;
491 }
492 if (!data.WriteString(TEST_STRING_VALUE)) {
493 return;
494 }
495 if (!data.WriteInt32(TEST_INT32_VALUE)) {
496 return;
497 }
498 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME);
499 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
500 }
501
502 /**
503 * @tc.name: OnGetIfaceNameIdentMapsTest001
504 * @tc.desc: Test NetConnServiceStub GetIfaceNameIdentMaps.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(NetConnServiceStubTest, OnGetIfaceNameIdentMapsTest001, TestSize.Level1)
508 {
509 NetManagerBaseAccessToken token;
510 MessageParcel data;
511 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
512 return;
513 }
514 if (!data.WriteUint32(0)) {
515 return;
516 }
517 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_GET_IFACENAME_IDENT_MAPS);
518 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
519 }
520
521 /**
522 * @tc.name: OnBindSocketTest001
523 * @tc.desc: Test NetConnServiceStub OnBindSocket.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(NetConnServiceStubTest, OnBindSocketTest001, TestSize.Level1)
527 {
528 MessageParcel data;
529 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
530 return;
531 }
532 if (!data.WriteInt32(TEST_INT32_VALUE)) {
533 return;
534 }
535 if (!data.WriteInt32(TEST_INT32_VALUE)) {
536 return;
537 }
538 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_BIND_SOCKET);
539 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
540 }
541
542 /**
543 * @tc.name: OnSetAirplaneModeTest001
544 * @tc.desc: Test NetConnServiceStub OnSetAirplaneMode.
545 * @tc.type: FUNC
546 */
547 HWTEST_F(NetConnServiceStubTest, OnSetAirplaneModeTest001, TestSize.Level1)
548 {
549 NetManagerBaseAccessToken token;
550 MessageParcel data;
551 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
552 return;
553 }
554 if (!data.WriteBool(TEST_BOOL_VALUE)) {
555 return;
556 }
557 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE);
558 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
559 }
560
561 /**
562 * @tc.name: OnIsDefaultNetMeteredTest001
563 * @tc.desc: Test NetConnServiceStub OnIsDefaultNetMetered.
564 * @tc.type: FUNC
565 */
566 HWTEST_F(NetConnServiceStubTest, OnIsDefaultNetMeteredTest001, TestSize.Level1)
567 {
568 NetManagerBaseAccessToken token;
569 MessageParcel data;
570 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
571 return;
572 }
573 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_IS_DEFAULT_NET_METERED);
574 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
575 }
576
577 /**
578 * @tc.name: OnSetGlobalHttpProxyTest001
579 * @tc.desc: Test NetConnServiceStub OnSetGlobalHttpProxy.
580 * @tc.type: FUNC
581 */
582 HWTEST_F(NetConnServiceStubTest, OnSetGlobalHttpProxyTest001, TestSize.Level1)
583 {
584 NetManagerBaseAccessToken token;
585 MessageParcel data;
586 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
587 return;
588 }
589 HttpProxy httpProxy = { TEST_DOMAIN, 8080, {} };
590 if (!httpProxy.Marshalling(data)) {
591 return;
592 }
593 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SET_GLOBAL_HTTP_PROXY);
594 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
595 }
596
597 /**
598 * @tc.name: OnGetGlobalHttpProxyTest001
599 * @tc.desc: Test NetConnServiceStub OnGetGlobalHttpProxy.
600 * @tc.type: FUNC
601 */
602 HWTEST_F(NetConnServiceStubTest, OnGetGlobalHttpProxyTest001, TestSize.Level1)
603 {
604 MessageParcel data;
605 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
606 return;
607 }
608 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_GLOBAL_HTTP_PROXY);
609 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
610 }
611
612 /**
613 * @tc.name: OnGetDefaultHttpProxyTest001
614 * @tc.desc: Test NetConnServiceStub OnGetDefaultHttpProxy.
615 * @tc.type: FUNC
616 */
617 HWTEST_F(NetConnServiceStubTest, OnGetDefaultHttpProxyTest001, TestSize.Level1)
618 {
619 MessageParcel data;
620 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
621 return;
622 }
623 if (!data.WriteInt32(TEST_INT32_VALUE)) {
624 return;
625 }
626 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_DEFAULT_HTTP_PROXY);
627 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
628 }
629
630 /**
631 * @tc.name: OnGetNetIdByIdentifierTest001
632 * @tc.desc: Test NetConnServiceStub OnGetNetIdByIdentifier.
633 * @tc.type: FUNC
634 */
635 HWTEST_F(NetConnServiceStubTest, OnGetNetIdByIdentifierTest001, TestSize.Level1)
636 {
637 MessageParcel data;
638 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
639 return;
640 }
641 if (!data.WriteString(TEST_STRING_VALUE)) {
642 return;
643 }
644 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER);
645 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
646 }
647
648 /**
649 * @tc.name: OnSetAppNetTest001
650 * @tc.desc: Test NetConnServiceStub OnSetAppNet.
651 * @tc.type: FUNC
652 */
653 HWTEST_F(NetConnServiceStubTest, OnSetAppNetTest001, TestSize.Level1)
654 {
655 NetManagerBaseAccessToken token;
656 MessageParcel data;
657 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
658 return;
659 }
660 if (!data.WriteInt32(TEST_INT32_VALUE)) {
661 return;
662 }
663 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_SET_APP_NET);
664 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
665 }
666
667 /**
668 * @tc.name: OnRegisterNetInterfaceCallbackTest001
669 * @tc.desc: Test NetConnServiceStub OnRegisterNetInterfaceCallback.
670 * @tc.type: FUNC
671 */
672 HWTEST_F(NetConnServiceStubTest, OnRegisterNetInterfaceCallbackTest001, TestSize.Level1)
673 {
674 NetManagerBaseAccessToken token;
675 MessageParcel data;
676 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
677 return;
678 }
679 sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
680 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
681 return;
682 }
683 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK);
684 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
685 }
686
687 /**
688 * @tc.name: OnAddNetworkRouteTest001
689 * @tc.desc: Test NetConnServiceStub OnAddNetworkRoute.
690 * @tc.type: FUNC
691 */
692 HWTEST_F(NetConnServiceStubTest, OnAddNetworkRouteTest001, TestSize.Level1)
693 {
694 NetManagerBaseAccessToken token;
695 MessageParcel data;
696 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
697 return;
698 }
699 if (!data.WriteInt32(TEST_INT32_VALUE)) {
700 return;
701 }
702
703 if (!data.WriteString(TEST_STRING_VALUE)) {
704 return;
705 }
706
707 if (!data.WriteString(TEST_STRING_VALUE)) {
708 return;
709 }
710
711 if (!data.WriteString(TEST_STRING_VALUE)) {
712 return;
713 }
714 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE);
715 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
716 }
717
718 /**
719 * @tc.name: OnRemoveNetworkRouteTest001
720 * @tc.desc: Test NetConnServiceStub OnRemoveNetworkRoute.
721 * @tc.type: FUNC
722 */
723 HWTEST_F(NetConnServiceStubTest, OnRemoveNetworkRouteTest001, TestSize.Level1)
724 {
725 NetManagerBaseAccessToken token;
726 MessageParcel data;
727 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
728 return;
729 }
730 if (!data.WriteInt32(TEST_INT32_VALUE)) {
731 return;
732 }
733
734 if (!data.WriteString(TEST_STRING_VALUE)) {
735 return;
736 }
737
738 if (!data.WriteString(TEST_STRING_VALUE)) {
739 return;
740 }
741
742 if (!data.WriteString(TEST_STRING_VALUE)) {
743 return;
744 }
745 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE);
746 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
747 }
748
749 /**
750 * @tc.name: OnAddInterfaceAddressTest001
751 * @tc.desc: Test NetConnServiceStub OnAddInterfaceAddress.
752 * @tc.type: FUNC
753 */
754 HWTEST_F(NetConnServiceStubTest, OnAddInterfaceAddressTest001, TestSize.Level1)
755 {
756 NetManagerBaseAccessToken token;
757 MessageParcel data;
758 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
759 return;
760 }
761
762 if (!data.WriteString(TEST_STRING_VALUE)) {
763 return;
764 }
765
766 if (!data.WriteString(TEST_STRING_VALUE)) {
767 return;
768 }
769
770 if (!data.WriteInt32(TEST_INT32_VALUE)) {
771 return;
772 }
773 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS);
774 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
775 }
776
777 /**
778 * @tc.name: OnDelInterfaceAddressTest001
779 * @tc.desc: Test NetConnServiceStub OnDelInterfaceAddress.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(NetConnServiceStubTest, OnDelInterfaceAddressTest001, TestSize.Level1)
783 {
784 NetManagerBaseAccessToken token;
785 MessageParcel data;
786 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
787 return;
788 }
789
790 if (!data.WriteString(TEST_STRING_VALUE)) {
791 return;
792 }
793
794 if (!data.WriteString(TEST_STRING_VALUE)) {
795 return;
796 }
797
798 if (!data.WriteInt32(TEST_INT32_VALUE)) {
799 return;
800 }
801 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS);
802 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
803 }
804
805 /**
806 * @tc.name: OnAddStaticArpTest001
807 * @tc.desc: Test NetConnServiceStub OnAddStaticArp.
808 * @tc.type: FUNC
809 */
810 HWTEST_F(NetConnServiceStubTest, OnAddStaticArpTest001, TestSize.Level1)
811 {
812 NetManagerBaseAccessToken token;
813 MessageParcel data;
814 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
815 return;
816 }
817
818 if (!data.WriteString(TEST_STRING_VALUE)) {
819 return;
820 }
821
822 if (!data.WriteString(TEST_STRING_VALUE)) {
823 return;
824 }
825
826 if (!data.WriteString(TEST_STRING_VALUE)) {
827 return;
828 }
829 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP);
830 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
831 }
832
833 /**
834 * @tc.name: OnDelStaticArpTest001
835 * @tc.desc: Test NetConnServiceStub OnDelStaticArp.
836 * @tc.type: FUNC
837 */
838 HWTEST_F(NetConnServiceStubTest, OnDelStaticArpTest001, TestSize.Level1)
839 {
840 NetManagerBaseAccessToken token;
841 MessageParcel data;
842 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
843 return;
844 }
845
846 if (!data.WriteString(TEST_STRING_VALUE)) {
847 return;
848 }
849
850 if (!data.WriteString(TEST_STRING_VALUE)) {
851 return;
852 }
853
854 if (!data.WriteString(TEST_STRING_VALUE)) {
855 return;
856 }
857 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP);
858 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
859 }
860
861 /**
862 * @tc.name: OnRegisterSlotTypeTest001
863 * @tc.desc: Test NetConnServiceStub OnRegisterSlotType.
864 * @tc.type: FUNC
865 */
866 HWTEST_F(NetConnServiceStubTest, OnRegisterSlotTypeTest001, TestSize.Level1)
867 {
868 NetManagerBaseAccessToken token;
869 MessageParcel data;
870 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
871 return;
872 }
873
874 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
875 return;
876 }
877
878 if (!data.WriteInt32(TEST_INT32_VALUE)) {
879 return;
880 }
881 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE);
882 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
883 }
884
885 /**
886 * @tc.name: OnGetSlotTypeTest001
887 * @tc.desc: Test NetConnServiceStub OnGetSlotType.
888 * @tc.type: FUNC
889 */
890 HWTEST_F(NetConnServiceStubTest, OnGetSlotTypeTest001, TestSize.Level1)
891 {
892 NetManagerBaseAccessToken token;
893 MessageParcel data;
894 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
895 return;
896 }
897
898 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_GET_SLOT_TYPE);
899 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
900 }
901
902 /**
903 * @tc.name: OnFactoryResetNetworkTest001
904 * @tc.desc: Test NetConnServiceStub OnFactoryResetNetwork.
905 * @tc.type: FUNC
906 */
907 HWTEST_F(NetConnServiceStubTest, OnFactoryResetNetworkTest001, TestSize.Level1)
908 {
909 NetManagerBaseAccessToken token;
910 MessageParcel data;
911 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
912 return;
913 }
914
915 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_FACTORYRESET_NETWORK);
916 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
917 }
918
919 /**
920 * @tc.name: OnRegisterNetFactoryResetCallbackTest001
921 * @tc.desc: Test NetConnServiceStub OnRegisterNetFactoryResetCallback.
922 * @tc.type: FUNC
923 */
924 HWTEST_F(NetConnServiceStubTest, OnRegisterNetFactoryResetCallbackTest001, TestSize.Level1)
925 {
926 NetManagerBaseAccessToken token;
927 MessageParcel data;
928 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
929 return;
930 }
931 sptr<INetFactoryResetCallbackTest> callback = new (std::nothrow) INetFactoryResetCallbackTest();
932 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
933 return;
934 }
935 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REGISTER_NET_FACTORYRESET_CALLBACK);
936 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
937 }
938
939 /**
940 * @tc.name: OnIsPreferCellularUrlTest001
941 * @tc.desc: Test NetConnServiceStub OnIsPreferCellularUrl.
942 * @tc.type: FUNC
943 */
944 HWTEST_F(NetConnServiceStubTest, OnIsPreferCellularUrlTest001, TestSize.Level1)
945 {
946 NetManagerBaseAccessToken token;
947 MessageParcel data;
948 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
949 return;
950 }
951 if (!data.WriteString(TEST_STRING_VALUE)) {
952 return;
953 }
954 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL);
955 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
956 }
957
958 /**
959 * @tc.name: OnUpdateSupplierScore001
960 * @tc.desc: Test NetConnServiceStub OnUpdateSupplierScore.
961 * @tc.type: FUNC
962 */
963 HWTEST_F(NetConnServiceStubTest, OnUpdateSupplierScore001, TestSize.Level1)
964 {
965 NetManagerBaseAccessToken token;
966 MessageParcel data;
967 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
968 return;
969 }
970 uint32_t bearerType = 0;
971 if (!data.WriteUint32(bearerType)) {
972 return;
973 }
974 if (!data.WriteUint32(QUALITY_GOOD_STATE)) {
975 return;
976 }
977 uint32_t supplierId = 100;
978 if (!data.WriteUint32(supplierId)) {
979 return;
980 }
981 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_UPDATE_SUPPLIER_SCORE);
982 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
983 }
984
985 /**
986 * @tc.name: OnRequestNetConnectionBySpecifierTest001
987 * @tc.desc: Test NetConnServiceStub OnRequestNetConnection.
988 * @tc.type: FUNC
989 */
990 HWTEST_F(NetConnServiceStubTest, OnRequestNetConnectionBySpecifierTest001, TestSize.Level1)
991 {
992 NetManagerBaseAccessToken token;
993 MessageParcel data;
994 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
995 return;
996 }
997
998 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
999 if (netSpecifier == nullptr) {
1000 return;
1001 }
1002
1003 if (!netSpecifier->Marshalling(data)) {
1004 return;
1005 }
1006
1007 if (!data.WriteUint32(TEST_UINT32_VALUE)) {
1008 return;
1009 }
1010
1011 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
1012 if (!data.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
1013 return;
1014 }
1015
1016 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_REQUEST_NET_CONNECTION);
1017 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1018 }
1019
1020 HWTEST_F(NetConnServiceStubTest, OnEnableVnicNetwork001, TestSize.Level1)
1021 {
1022 NetManagerBaseAccessToken token;
1023 MessageParcel data;
1024 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
1025 return;
1026 }
1027
1028 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
1029 if (netLinkInfo == nullptr) {
1030 return;
1031 }
1032
1033 if (!netLinkInfo->Marshalling(data)) {
1034 return;
1035 }
1036
1037 std::set<int32_t> uids;
1038 if (!data.WriteInt32(uids.size())) {
1039 return;
1040 }
1041
1042 for (const auto &uid: uids) {
1043 if (!data.WriteInt32(uid)) {
1044 return;
1045 }
1046 }
1047
1048 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_ENABLE_VNIC_NET_WORK);
1049 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1050 }
1051
1052 HWTEST_F(NetConnServiceStubTest, OnDisableVnicNetwork001, TestSize.Level1)
1053 {
1054 NetManagerBaseAccessToken token;
1055 MessageParcel data;
1056 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
1057 return;
1058 }
1059 int32_t ret = SendRemoteRequest(data, ConnInterfaceCode::CMD_NM_DISABLE_VNIC_NET_WORK);
1060 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1061 }
1062 } // namespace NetManagerStandard
1063 } // namespace OHOS