1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifdef FEATURE_NETWORK_SUPPORT
17 #include "network_ability_test.h"
18 
19 #define private public
20 #include "network_ability.h"
21 #undef private
22 #include <cstdlib>
23 #include "accesstoken_kit.h"
24 #include "if_system_ability_manager.h"
25 #include "ipc_skeleton.h"
26 #include "iservice_registry.h"
27 #include "message_parcel.h"
28 #include "nativetoken_kit.h"
29 #include "system_ability_definition.h"
30 #include "token_setproc.h"
31 
32 #include "common_utils.h"
33 #include "constant_definition.h"
34 #include "location.h"
35 #include "location_dumper.h"
36 #include "location_log.h"
37 #include "network_ability_skeleton.h"
38 #include "gmock/gmock.h"
39 #include "common_utils.h"
40 #include "mock_i_remote_object.h"
41 
42 #include <gtest/gtest.h>
43 #include "network_callback_host.h"
44 #include "permission_manager.h"
45 #include "locationhub_ipc_interface_code.h"
46 #include "location_data_rdb_manager.h"
47 
48 #include "locationhub_ipc_interface_code.h"
49 #include "location_sa_load_manager.h"
50 #include "system_ability_definition.h"
51 #include "if_system_ability_manager.h"
52 #include "iservice_registry.h"
53 #include "location_log.h"
54 
55 #include "bundle_mgr_interface.h"
56 #include "bundle_mgr_proxy.h"
57 #include "parameter.h"
58 #include "accesstoken_kit.h"
59 #include "os_account_manager.h"
60 
61 using namespace testing;
62 using namespace testing::ext;
63 namespace OHOS {
64 namespace Location {
65 const int32_t LOCATION_PERM_NUM = 5;
66 const std::string ARGS_HELP = "-h";
67 const std::string UNLOAD_NETWORK_TASK = "network_sa_unload";
68 const int32_t WAIT_EVENT_TIME = 1;
SetUp()69 void NetworkAbilityTest::SetUp()
70 {
71     /*
72      * @tc.setup: Get system ability's pointer and get sa proxy object.
73      */
74     MockNativePermission();
75     ability_ = new (std::nothrow) NetworkAbility();
76     EXPECT_NE(nullptr, ability_);
77     proxy_ = new (std::nothrow) NetworkAbilityProxy(ability_);
78     EXPECT_NE(nullptr, proxy_);
79 }
80 
TearDown()81 void NetworkAbilityTest::TearDown()
82 {
83     /*
84      * @tc.teardown: release memory.
85      */
86     ability_->networkHandler_->RemoveTask(UNLOAD_NETWORK_TASK);
87     sleep(WAIT_EVENT_TIME);
88     proxy_ = nullptr;
89     ability_ = nullptr;
90 }
91 
TearDownTestCase()92 void NetworkAbilityTest::TearDownTestCase()
93 {
94     /*
95      * @tc.teardown: release memory.
96      */
97     sleep(WAIT_EVENT_TIME);
98 }
99 
MockNativePermission()100 void NetworkAbilityTest::MockNativePermission()
101 {
102     const char *perms[] = {
103         ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
104         ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
105         ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
106     };
107     NativeTokenInfoParams infoInstance = {
108         .dcapsNum = 0,
109         .permsNum = LOCATION_PERM_NUM,
110         .aclsNum = 0,
111         .dcaps = nullptr,
112         .perms = perms,
113         .acls = nullptr,
114         .processName = "NetworkAbilityTest",
115         .aplStr = "system_basic",
116     };
117     uint64_t tokenId = GetAccessTokenId(&infoInstance);
118     SetSelfTokenID(tokenId);
119     Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
120 }
121 
122 /*
123  * @tc.name: SendLocationRequest001
124  * @tc.desc: Build Request, marshall and unmarshall data Then Send it
125  * @tc.type: FUNC
126  */
127 HWTEST_F(NetworkAbilityTest, SendLocationRequest001, TestSize.Level1)
128 {
129     GTEST_LOG_(INFO)
130         << "NetworkAbilityTest, SendLocationRequest001, TestSize.Level1";
131     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 begin");
132     /*
133      * @tc.steps: step1. build location request data.
134      */
135     std::unique_ptr<WorkRecord> workRecord = std::make_unique<WorkRecord>();
136     int num = 2;
137     for (int i = 0; i < num; i++) {
138         std::shared_ptr<Request> request = std::make_shared<Request>();
139         std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
140         requestConfig->SetTimeInterval(i);
141         request->SetUid(i + 1);
142         request->SetPid(i + 2);
143         request->SetPackageName("nameForTest");
144         request->SetRequestConfig(*requestConfig);
145         request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
146         request->SetNlpRequestType(i + 1);
147         workRecord->Add(request);
148     }
149     /*
150      * @tc.steps: step2. send location request
151      * @tc.expected: step2. no exception happens.
152      */
153     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendLocationRequest(*workRecord));
154     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 end");
155 }
156 
157 /*
158  * @tc.name: SetEnableAndDisable001
159  * @tc.desc: Test disable and enable system ability
160  * @tc.type: FUNC
161  */
162 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1)
163 {
164     GTEST_LOG_(INFO)
165         << "NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1";
166     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 begin");
167     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false));
168     /*
169      * @tc.steps: step1.remove SA
170      * @tc.expected: step1. object1 is null.
171      */
172     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false)); // after mock, sa obj is nullptr
173 
174     /*
175      * @tc.steps: step2. test enable SA
176      * @tc.expected: step2. object2 is not null.
177      */
178     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(true)); // after mock, sa obj is nullptr
179     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 end");
180 }
181 
182 HWTEST_F(NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1)
183 {
184     GTEST_LOG_(INFO)
185         << "NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1";
186     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 begin");
187     int timeInterval = 1;
188     std::vector<std::shared_ptr<Location>> locations;
189     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->EnableMock());
190     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetMocked(timeInterval, locations));
191 
192     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->DisableMock());
193     EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->SetMocked(timeInterval, locations));
194     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 end");
195 }
196 
197 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1)
198 {
199     GTEST_LOG_(INFO)
200         << "NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1";
201     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 begin");
202     ability_->OnStart(); // start ability
203     EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
204         (ServiceRunningState)ability_->QueryServiceState()); // after mock
205     ability_->OnStart(); // start ability again
206     EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
207         (ServiceRunningState)ability_->QueryServiceState()); // after mock
208 
209     ability_->OnStop(); // stop ability
210     EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
211         (ServiceRunningState)ability_->QueryServiceState()); // after mock
212     ability_->OnStart(); // restart ability
213     EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
214         (ServiceRunningState)ability_->QueryServiceState()); // after mock
215     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 end");
216 }
217 
218 HWTEST_F(NetworkAbilityTest, NetworkDump001, TestSize.Level1)
219 {
220     GTEST_LOG_(INFO)
221         << "NetworkAbilityTest, NetworkDump001, TestSize.Level1";
222     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 begin");
223     int32_t fd = 0;
224     std::vector<std::u16string> args;
225     std::u16string arg1 = Str8ToStr16("arg1");
226     args.emplace_back(arg1);
227     std::u16string arg2 = Str8ToStr16("arg2");
228     args.emplace_back(arg2);
229     std::u16string arg3 = Str8ToStr16("arg3");
230     args.emplace_back(arg3);
231     std::u16string arg4 = Str8ToStr16("arg4");
232     args.emplace_back(arg4);
233     EXPECT_EQ(ERR_OK, ability_->Dump(fd, args));
234 
235     std::vector<std::u16string> emptyArgs;
236     EXPECT_EQ(ERR_OK, ability_->Dump(fd, emptyArgs));
237 
238     std::vector<std::u16string> helpArgs;
239     std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
240     helpArgs.emplace_back(helpArg1);
241     EXPECT_EQ(ERR_OK, ability_->Dump(fd, helpArgs));
242     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 end");
243 }
244 
245 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1)
246 {
247     GTEST_LOG_(INFO)
248         << "NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1";
249     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 begin");
250     ability_->SendReportMockLocationEvent(); // clear location mock
251 
252     int timeInterval = 0;
253     std::vector<std::shared_ptr<Location>> locations;
254     Parcel parcel;
255     parcel.WriteDouble(10.6); // latitude
256     parcel.WriteDouble(10.5); // longitude
257     parcel.WriteDouble(10.4); // altitude
258     parcel.WriteDouble(1.0); // accuracy
259     parcel.WriteDouble(5.0); // speed
260     parcel.WriteDouble(10); // direction
261     parcel.WriteInt64(1611000000); // timestamp
262     parcel.WriteInt64(1611000000); // time since boot
263     parcel.WriteString16(u"additions"); // additions
264     parcel.WriteInt64(1); // additionSize
265     parcel.WriteInt32(1); // isFromMock is true
266     locations.push_back(Location::UnmarshallingShared(parcel));
267     EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
268     EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
269     sleep(2);
270     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 end");
271 }
272 
273 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1)
274 {
275     GTEST_LOG_(INFO)
276         << "NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1";
277     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 begin");
278     ability_->SendReportMockLocationEvent(); // clear location mock
279 
280     int timeInterval = 0;
281     std::vector<std::shared_ptr<Location>> locations;
282     Parcel parcel;
283     parcel.WriteDouble(10.6); // latitude
284     parcel.WriteDouble(10.5); // longitude
285     parcel.WriteDouble(10.4); // altitude
286     parcel.WriteDouble(1.0); // accuracy
287     parcel.WriteDouble(5.0); // speed
288     parcel.WriteDouble(10); // direction
289     parcel.WriteInt64(1611000000); // timestamp
290     parcel.WriteInt64(1611000000); // time since boot
291     parcel.WriteString16(u"additions"); // additions
292     parcel.WriteInt64(1); // additionSize
293     parcel.WriteInt32(0); // isFromMock is false
294     locations.push_back(Location::UnmarshallingShared(parcel));
295     EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
296     EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
297     sleep(2);
298     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 end");
299 }
300 
301 /*
302  * @tc.name: NetworkConnectNlpService001
303  * @tc.desc: connect nlp service
304  * @tc.type: FUNC
305  */
306 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1)
307 {
308     GTEST_LOG_(INFO)
309         << "NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1";
310     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 begin");
311     EXPECT_EQ(false, ability_->ReConnectNlpService());
312     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 end");
313 }
314 
315 HWTEST_F(NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1)
316 {
317     GTEST_LOG_(INFO)
318         << "NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1";
319     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 begin");
320     auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
321     EXPECT_EQ(false, ability->ReConnectNlpService()); // Connect success
322     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 end");
323 }
324 
325 HWTEST_F(NetworkAbilityTest, NotifyConnected001, TestSize.Level1)
326 {
327     GTEST_LOG_(INFO)
328         << "NetworkAbilityTest, NotifyConnected001, TestSize.Level1";
329     LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 begin");
330     auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
331     sptr<IRemoteObject> obj = nullptr;
332     ability->NotifyConnected(obj);
333     EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
334 
335     ability->NotifyDisConnected();
336     EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
337     LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 end");
338 }
339 
340 HWTEST_F(NetworkAbilityTest, SendLocationRequest002, TestSize.Level1)
341 {
342     GTEST_LOG_(INFO)
343         << "NetworkAbilityTest, SendLocationRequest002, TestSize.Level1";
344     LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 begin");
345     auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
346     WorkRecord workRecord;
347     ability->SendLocationRequest(workRecord);
348     LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 end");
349 }
350 
351 HWTEST_F(NetworkAbilityTest, RequestRecord001, TestSize.Level1)
352 {
353     GTEST_LOG_(INFO)
354         << "NetworkAbilityTest, RequestRecord001, TestSize.Level1";
355     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 begin");
356     auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
357     WorkRecord workRecord;
358     ability->RequestRecord(workRecord, true);
359     ability->RequestRecord(workRecord, false);
360     sptr<MockIRemoteObject> nlpServiceProxy =
361         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
362     EXPECT_NE(nullptr, nlpServiceProxy);
363     ability->nlpServiceProxy_ = nlpServiceProxy;
364     ability->RequestRecord(workRecord, true);
365     ability->RequestRecord(workRecord, false);
366     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 end");
367 }
368 
369 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1)
370 {
371     GTEST_LOG_(INFO)
372         << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1";
373     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 begin");
374     sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
375     uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT);
376     MessageParcel data;
377     data.WriteInterfaceToken(u"location.ILocatorCallback");
378     MessageParcel reply;
379     MessageOption option;
380     EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
381     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 end");
382 }
383 
384 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1)
385 {
386     GTEST_LOG_(INFO)
387         << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1";
388     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 begin");
389     sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
390     uint32_t code = 0;
391     MessageParcel data;
392     data.WriteInterfaceToken(u"location.ILocatorCallback");
393     MessageParcel reply;
394     MessageOption option;
395     EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
396     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 end");
397 }
398 
399 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1)
400 {
401     GTEST_LOG_(INFO)
402         << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1";
403     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 begin");
404     sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
405     uint32_t code = 0;
406     MessageParcel data;
407     data.WriteInterfaceToken(u"wrong.interface.token");
408     MessageParcel reply;
409     MessageOption option;
410     EXPECT_EQ(-1, callback->OnRemoteRequest(code, data, reply, option));
411     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 end");
412 }
413 
414 HWTEST_F(NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1)
415 {
416     GTEST_LOG_(INFO)
417         << "NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1";
418     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 begin");
419     ability_->registerToAbility_ = false;
420     bool ret = ability_->Init(); // after mock, sa obj is nullptr
421     EXPECT_EQ(false, ret);
422 
423     ability_->registerToAbility_ = true;
424     ret = ability_->Init();
425     EXPECT_EQ(true, ret);
426     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 end");
427 }
428 
429 HWTEST_F(NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1)
430 {
431     GTEST_LOG_(INFO)
432         << "NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1";
433     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 begin");
434     bool ret = ability_->ConnectNlpService();
435     EXPECT_EQ(false, ret);
436     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 end");
437 }
438 
439 HWTEST_F(NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1)
440 {
441     GTEST_LOG_(INFO)
442         << "NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1";
443     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 begin");
444     bool ret = ability_->ReConnectNlpService();
445     EXPECT_EQ(false, ret);
446     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 end");
447 }
448 
449 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1)
450 {
451     GTEST_LOG_(INFO)
452         << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1";
453     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 begin");
454     std::vector<std::shared_ptr<Location>> locations;
455     Parcel parcel;
456     parcel.WriteDouble(10.6); // latitude
457     parcel.WriteDouble(10.5); // longitude
458     parcel.WriteDouble(10.4); // altitude
459     parcel.WriteDouble(1.0); // accuracy
460     parcel.WriteDouble(5.0); // speed
461     parcel.WriteDouble(10); // direction
462     parcel.WriteInt64(1611000000); // timestamp
463     parcel.WriteInt64(1611000000); // time since boot
464     parcel.WriteString16(u"additions"); // additions
465     parcel.WriteInt64(1); // additionSize
466     parcel.WriteInt32(1); // isFromMock is true
467     locations.push_back(Location::UnmarshallingShared(parcel));
468     ability_->ProcessReportLocationMock();
469     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 end");
470 }
471 
472 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock002, TestSize.Level1)
473 {
474     GTEST_LOG_(INFO)
475         << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock002, TestSize.Level1";
476     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock002 begin");
477     std::vector<std::shared_ptr<Location>> locations;
478     Parcel parcel;
479     parcel.WriteDouble(10.6); // latitude
480     parcel.WriteDouble(10.5); // longitude
481     parcel.WriteDouble(10.4); // altitude
482     parcel.WriteDouble(1.0); // accuracy
483     parcel.WriteDouble(5.0); // speed
484     parcel.WriteDouble(10); // direction
485     parcel.WriteInt64(1611000000); // timestamp
486     parcel.WriteInt64(1611000000); // time since boot
487     parcel.WriteString16(u"additions"); // additions
488     parcel.WriteInt64(1); // additionSize
489     parcel.WriteInt32(1); // isFromMock is true
490     locations.push_back(Location::UnmarshallingShared(parcel));
491     ability_->CacheLocationMock(locations);
492     ability_->ProcessReportLocationMock();
493     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock002 end");
494 }
495 
496 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1)
497 {
498     GTEST_LOG_(INFO)
499         << "NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1";
500     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 begin");
501 
502     ability_->SendReportMockLocationEvent();
503     LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 end");
504 }
505 
506 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendMessage001, TestSize.Level1)
507 {
508     GTEST_LOG_(INFO)
509         << "NetworkAbilityStubTest, NetworkAbilitySendMessage001, TestSize.Level1";
510     LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 begin");
511     MessageParcel requestParcel;
512     requestParcel.WriteInterfaceToken(u"location.INetworkAbility");
513     requestParcel.WriteBuffer("data", 4);
514     requestParcel.RewindRead(0);
515 
516     MessageParcel reply;
517 
518     ability_->SendMessage(0, requestParcel, reply);
519     LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 end");
520 }
521 
522 HWTEST_F(NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1)
523 {
524     GTEST_LOG_(INFO)
525         << "NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1";
526     LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 begin");
527     auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
528     EXPECT_EQ(true, ability->ResetServiceProxy()); // Connect success
529     LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 end");
530 }
531 
532 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1)
533 {
534     GTEST_LOG_(INFO)
535         << "NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1";
536     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 begin");
537     auto workRecord = std::make_shared<WorkRecord>();
538     sptr<MockIRemoteObject> nlpServiceProxy =
539         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
540     EXPECT_NE(nullptr, nlpServiceProxy);
541     ability_->nlpServiceProxy_ = nlpServiceProxy;
542     std::shared_ptr<Request> request = std::make_shared<Request>();
543     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
544     requestConfig->SetTimeInterval(0);
545     request->SetUid(1);
546     request->SetPid(2);
547     request->SetPackageName("nameForTest");
548     request->SetRequestConfig(*requestConfig);
549     request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
550     request->SetNlpRequestType(1);
551     workRecord->Add(request);
552     ability_->RequestNetworkLocation(*workRecord);
553     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 end");
554 }
555 
556 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1)
557 {
558     GTEST_LOG_(INFO)
559         << "NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1";
560     LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 begin");
561     auto workRecord = std::make_shared<WorkRecord>();
562     sptr<MockIRemoteObject> nlpServiceProxy =
563         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
564     EXPECT_NE(nullptr, nlpServiceProxy);
565     ability_->nlpServiceProxy_ = nlpServiceProxy;
566     std::shared_ptr<Request> request = std::make_shared<Request>();
567     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
568     requestConfig->SetTimeInterval(0);
569     request->SetUid(1);
570     request->SetPid(2);
571     request->SetPackageName("nameForTest");
572     request->SetRequestConfig(*requestConfig);
573     request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
574     request->SetNlpRequestType(1);
575     workRecord->Add(request);
576     ability_->RemoveNetworkLocation(*workRecord);
577     LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 end");
578 }
579 
580 #ifdef FEATURE_PASSIVE_SUPPORT
581 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
582 {
583     GTEST_LOG_(INFO)
584         << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
585     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
586     std::vector<std::shared_ptr<Location>> locations;
587     Parcel parcel;
588     parcel.WriteDouble(10.6); // latitude
589     parcel.WriteDouble(10.5); // longitude
590     parcel.WriteDouble(10.4); // altitude
591     parcel.WriteDouble(1.0); // accuracy
592     parcel.WriteDouble(5.0); // speed
593     parcel.WriteDouble(10); // direction
594     parcel.WriteInt64(1611000000); // timestamp
595     parcel.WriteInt64(1611000000); // time since boot
596     parcel.WriteString16(u"additions"); // additions
597     parcel.WriteInt64(1); // additionSize
598     parcel.WriteInt32(1); // isFromMock is true
599     locations.push_back(Location::UnmarshallingShared(parcel));
600     ability_->ReportMockedLocation(locations);
601     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
602 }
603 #endif
604 
605 HWTEST_F(NetworkAbilityTest, RegisterNlpServiceDeathRecipient001, TestSize.Level1)
606 {
607     GTEST_LOG_(INFO)
608         << "NetworkAbilityTest, RegisterNlpServiceDeathRecipient001, TestSize.Level1";
609     LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient001 begin");
610     ability_->RegisterNlpServiceDeathRecipient();
611     LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient001 end");
612 }
613 
614 HWTEST_F(NetworkAbilityTest, ReportLocationError001, TestSize.Level1)
615 {
616     GTEST_LOG_(INFO)
617         << "NetworkAbilityTest, ReportLocationError001, TestSize.Level1";
618     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 begin");
619     ability_->ReportLocationError(0, "", "");
620     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 end");
621 }
622 
623 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
624 {
625     GTEST_LOG_(INFO)
626         << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
627     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
628     std::shared_ptr<Location> location = std::make_shared<Location>();
629     ability_->ReportMockedLocation(location);
630     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
631 }
632 
633 HWTEST_F(NetworkAbilityTest, OnRemoteDied001, TestSize.Level1)
634 {
635     GTEST_LOG_(INFO)
636         << "NetworkAbilityTest, OnRemoteDied001, TestSize.Level1";
637     LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 begin");
638     auto deathRecipient = new (std::nothrow) NlpServiceDeathRecipient();
639     const wptr<IRemoteObject> object;
640     deathRecipient->OnRemoteDied(object);
641     LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 end");
642 }
643 
644 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1)
645 {
646     GTEST_LOG_(INFO)
647         << "NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1";
648     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 begin");
649     ability_->state_ = ServiceRunningState::STATE_RUNNING;
650     ability_->OnStart(); // start ability
651     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 end");
652 }
653 
654 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1)
655 {
656     GTEST_LOG_(INFO)
657         << "NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1";
658     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 begin");
659     sptr<MockIRemoteObject> nlpServiceProxy =
660         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
661     EXPECT_NE(nullptr, nlpServiceProxy);
662     ability_->nlpServiceProxy_ = nlpServiceProxy;
663     ability_->ConnectNlpService();
664     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 end");
665 }
666 
667 HWTEST_F(NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1)
668 {
669     GTEST_LOG_(INFO)
670         << "NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1";
671     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 begin");
672     sptr<MockIRemoteObject> nlpServiceProxy =
673         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
674     EXPECT_NE(nullptr, nlpServiceProxy);
675     ability_->nlpServiceProxy_ = nlpServiceProxy;
676     ability_->ReConnectNlpService(); // Connect success
677     LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 end");
678 }
679 
680 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1)
681 {
682     GTEST_LOG_(INFO)
683         << "NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1";
684     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 begin");
685     /*
686      * @tc.steps: step1.remove SA
687      * @tc.expected: step1. object1 is null.
688      */
689 
690     ability_->SetEnable(false); // after mock, sa obj is nullptr
691     /*
692      * @tc.steps: step2. test enable SA
693      * @tc.expected: step2. object2 is not null.
694      */
695     ability_->SetEnable(true); // after mock, sa obj is nullptr
696     LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 end");
697 }
698 
699 HWTEST_F(NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1)
700 {
701     GTEST_LOG_(INFO)
702         << "NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1";
703     LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 begin");
704 
705     ability_->UnloadNetworkSystemAbility();
706     LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 end");
707 }
708 
709 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1)
710 {
711     GTEST_LOG_(INFO)
712         << "NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1";
713     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 begin");
714     ability_->nlpServiceProxy_ = nullptr;
715     WorkRecord workRecord;
716     EXPECT_EQ(false, ability_->RequestNetworkLocation(workRecord));
717     LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 end");
718 }
719 
720 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1)
721 {
722     GTEST_LOG_(INFO)
723         << "NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1";
724     LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 begin");
725     ability_->nlpServiceProxy_ = nullptr;
726     WorkRecord workRecord;
727     EXPECT_EQ(false, ability_->RemoveNetworkLocation(workRecord));
728     LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 end");
729 }
730 
731 HWTEST_F(NetworkAbilityTest, RegisterNlpServiceDeathRecipient002, TestSize.Level1)
732 {
733     GTEST_LOG_(INFO)
734         << "NetworkAbilityTest, RegisterNlpServiceDeathRecipient002, TestSize.Level1";
735     LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient002 begin");
736     sptr<MockIRemoteObject> nlpServiceProxy =
737         sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
738     EXPECT_NE(nullptr, nlpServiceProxy);
739     ability_->nlpServiceProxy_ = nlpServiceProxy;
740     ability_->RegisterNlpServiceDeathRecipient();
741     LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient002 end");
742 }
743 } // namespace Location
744 } // namespace OHOS
745 #endif // FEATURE_NETWORK_SUPPORT