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 ability_->networkHandler_ =
77 std::make_shared<NetworkHandler>(AppExecFwk::EventRunner::Create(true, AppExecFwk::ThreadMode::FFRT));
78 EXPECT_NE(nullptr, ability_);
79 proxy_ = new (std::nothrow) NetworkAbilityProxy(ability_);
80 EXPECT_NE(nullptr, proxy_);
81 }
82
TearDown()83 void NetworkAbilityTest::TearDown()
84 {
85 /*
86 * @tc.teardown: release memory.
87 */
88 ability_->networkHandler_->RemoveTask(UNLOAD_NETWORK_TASK);
89 sleep(WAIT_EVENT_TIME);
90 proxy_ = nullptr;
91 ability_ = nullptr;
92 }
93
TearDownTestCase()94 void NetworkAbilityTest::TearDownTestCase()
95 {
96 /*
97 * @tc.teardown: release memory.
98 */
99 sleep(WAIT_EVENT_TIME);
100 }
101
MockNativePermission()102 void NetworkAbilityTest::MockNativePermission()
103 {
104 const char *perms[] = {
105 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
106 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
107 ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
108 };
109 NativeTokenInfoParams infoInstance = {
110 .dcapsNum = 0,
111 .permsNum = LOCATION_PERM_NUM,
112 .aclsNum = 0,
113 .dcaps = nullptr,
114 .perms = perms,
115 .acls = nullptr,
116 .processName = "NetworkAbilityTest",
117 .aplStr = "system_basic",
118 };
119 uint64_t tokenId = GetAccessTokenId(&infoInstance);
120 SetSelfTokenID(tokenId);
121 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
122 }
123
124 /*
125 * @tc.name: SendLocationRequest001
126 * @tc.desc: Build Request, marshall and unmarshall data Then Send it
127 * @tc.type: FUNC
128 */
129 HWTEST_F(NetworkAbilityTest, SendLocationRequest001, TestSize.Level0)
130 {
131 GTEST_LOG_(INFO)
132 << "NetworkAbilityTest, SendLocationRequest001, TestSize.Level0";
133 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 begin");
134 /*
135 * @tc.steps: step1. build location request data.
136 */
137 std::unique_ptr<WorkRecord> workRecord = std::make_unique<WorkRecord>();
138 int num = 2;
139 for (int i = 0; i < num; i++) {
140 std::shared_ptr<Request> request = std::make_shared<Request>();
141 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
142 requestConfig->SetTimeInterval(i);
143 request->SetUid(i + 1);
144 request->SetPid(i + 2);
145 request->SetPackageName("nameForTest");
146 request->SetRequestConfig(*requestConfig);
147 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
148 request->SetNlpRequestType(i + 1);
149 workRecord->Add(request);
150 }
151 /*
152 * @tc.steps: step2. send location request
153 * @tc.expected: step2. no exception happens.
154 */
155 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendLocationRequest(*workRecord));
156 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 end");
157 }
158
159 /*
160 * @tc.name: SetEnableAndDisable001
161 * @tc.desc: Test disable and enable system ability
162 * @tc.type: FUNC
163 */
164 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level0)
165 {
166 GTEST_LOG_(INFO)
167 << "NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level0";
168 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 begin");
169 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false));
170 /*
171 * @tc.steps: step1.remove SA
172 * @tc.expected: step1. object1 is null.
173 */
174 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false)); // after mock, sa obj is nullptr
175
176 /*
177 * @tc.steps: step2. test enable SA
178 * @tc.expected: step2. object2 is not null.
179 */
180 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(true)); // after mock, sa obj is nullptr
181 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 end");
182 }
183
184 HWTEST_F(NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO)
187 << "NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1";
188 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 begin");
189 int timeInterval = 1;
190 std::vector<std::shared_ptr<Location>> locations;
191 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->EnableMock());
192 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetMocked(timeInterval, locations));
193
194 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->DisableMock());
195 EXPECT_EQ(LOCATION_ERRCODE_NOT_SUPPORTED, proxy_->SetMocked(timeInterval, locations));
196 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 end");
197 }
198
199 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1)
200 {
201 GTEST_LOG_(INFO)
202 << "NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1";
203 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 begin");
204 ability_->OnStart(); // start ability
205 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
206 (ServiceRunningState)ability_->QueryServiceState()); // after mock
207 ability_->OnStart(); // start ability again
208 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
209 (ServiceRunningState)ability_->QueryServiceState()); // after mock
210
211 ability_->OnStop(); // stop ability
212 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
213 (ServiceRunningState)ability_->QueryServiceState()); // after mock
214 ability_->OnStart(); // restart ability
215 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
216 (ServiceRunningState)ability_->QueryServiceState()); // after mock
217 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 end");
218 }
219
220 HWTEST_F(NetworkAbilityTest, NetworkDump001, TestSize.Level1)
221 {
222 GTEST_LOG_(INFO)
223 << "NetworkAbilityTest, NetworkDump001, TestSize.Level1";
224 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 begin");
225 int32_t fd = 0;
226 std::vector<std::u16string> args;
227 std::u16string arg1 = Str8ToStr16("arg1");
228 args.emplace_back(arg1);
229 std::u16string arg2 = Str8ToStr16("arg2");
230 args.emplace_back(arg2);
231 std::u16string arg3 = Str8ToStr16("arg3");
232 args.emplace_back(arg3);
233 std::u16string arg4 = Str8ToStr16("arg4");
234 args.emplace_back(arg4);
235 EXPECT_EQ(ERR_OK, ability_->Dump(fd, args));
236
237 std::vector<std::u16string> emptyArgs;
238 EXPECT_EQ(ERR_OK, ability_->Dump(fd, emptyArgs));
239
240 std::vector<std::u16string> helpArgs;
241 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
242 helpArgs.emplace_back(helpArg1);
243 EXPECT_EQ(ERR_OK, ability_->Dump(fd, helpArgs));
244 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 end");
245 }
246
247 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1)
248 {
249 GTEST_LOG_(INFO)
250 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1";
251 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 begin");
252 ability_->SendReportMockLocationEvent(); // clear location mock
253
254 int timeInterval = 0;
255 std::vector<std::shared_ptr<Location>> locations;
256 Parcel parcel;
257 parcel.WriteDouble(10.6); // latitude
258 parcel.WriteDouble(10.5); // longitude
259 parcel.WriteDouble(10.4); // altitude
260 parcel.WriteDouble(1.0); // accuracy
261 parcel.WriteDouble(5.0); // speed
262 parcel.WriteDouble(10); // direction
263 parcel.WriteInt64(1611000000); // timestamp
264 parcel.WriteInt64(1611000000); // time since boot
265 parcel.WriteString16(u"additions"); // additions
266 parcel.WriteInt64(1); // additionSize
267 parcel.WriteInt32(1); // isFromMock is true
268 locations.push_back(Location::UnmarshallingShared(parcel));
269 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
270 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
271 sleep(2);
272 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 end");
273 }
274
275 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO)
278 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1";
279 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 begin");
280 ability_->SendReportMockLocationEvent(); // clear location mock
281
282 int timeInterval = 0;
283 std::vector<std::shared_ptr<Location>> locations;
284 Parcel parcel;
285 parcel.WriteDouble(10.6); // latitude
286 parcel.WriteDouble(10.5); // longitude
287 parcel.WriteDouble(10.4); // altitude
288 parcel.WriteDouble(1.0); // accuracy
289 parcel.WriteDouble(5.0); // speed
290 parcel.WriteDouble(10); // direction
291 parcel.WriteInt64(1611000000); // timestamp
292 parcel.WriteInt64(1611000000); // time since boot
293 parcel.WriteString16(u"additions"); // additions
294 parcel.WriteInt64(1); // additionSize
295 parcel.WriteInt32(0); // isFromMock is false
296 locations.push_back(Location::UnmarshallingShared(parcel));
297 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
298 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
299 sleep(2);
300 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 end");
301 }
302
303 /*
304 * @tc.name: NetworkConnectNlpService001
305 * @tc.desc: connect nlp service
306 * @tc.type: FUNC
307 */
308 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1)
309 {
310 GTEST_LOG_(INFO)
311 << "NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1";
312 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 begin");
313 EXPECT_EQ(false, ability_->ReConnectNlpService());
314 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 end");
315 }
316
317 HWTEST_F(NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO)
320 << "NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1";
321 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 begin");
322 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
323 EXPECT_EQ(false, ability->ReConnectNlpService()); // Connect success
324 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 end");
325 }
326
327 HWTEST_F(NetworkAbilityTest, NotifyConnected001, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO)
330 << "NetworkAbilityTest, NotifyConnected001, TestSize.Level1";
331 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 begin");
332 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
333 sptr<IRemoteObject> obj = nullptr;
334 ability->NotifyConnected(obj);
335 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
336
337 ability->NotifyDisConnected();
338 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
339 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 end");
340 }
341
342 HWTEST_F(NetworkAbilityTest, SendLocationRequest002, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO)
345 << "NetworkAbilityTest, SendLocationRequest002, TestSize.Level1";
346 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 begin");
347 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
348 WorkRecord workRecord;
349 ability->SendLocationRequest(workRecord);
350 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 end");
351 }
352
353 HWTEST_F(NetworkAbilityTest, RequestRecord001, TestSize.Level1)
354 {
355 GTEST_LOG_(INFO)
356 << "NetworkAbilityTest, RequestRecord001, TestSize.Level1";
357 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 begin");
358 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
359 WorkRecord workRecord;
360 ability->RequestRecord(workRecord, true);
361 ability->RequestRecord(workRecord, false);
362 sptr<MockIRemoteObject> nlpServiceProxy =
363 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
364 EXPECT_NE(nullptr, nlpServiceProxy);
365 ability->nlpServiceProxy_ = nlpServiceProxy;
366 ability->RequestRecord(workRecord, true);
367 ability->RequestRecord(workRecord, false);
368 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 end");
369 }
370
371 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1)
372 {
373 GTEST_LOG_(INFO)
374 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1";
375 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 begin");
376 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
377 uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT);
378 MessageParcel data;
379 data.WriteInterfaceToken(u"location.ILocatorCallback");
380 MessageParcel reply;
381 MessageOption option;
382 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
383 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 end");
384 }
385
386 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1)
387 {
388 GTEST_LOG_(INFO)
389 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1";
390 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 begin");
391 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
392 uint32_t code = 0;
393 MessageParcel data;
394 data.WriteInterfaceToken(u"location.ILocatorCallback");
395 MessageParcel reply;
396 MessageOption option;
397 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
398 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 end");
399 }
400
401 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO)
404 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1";
405 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 begin");
406 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
407 uint32_t code = 0;
408 MessageParcel data;
409 data.WriteInterfaceToken(u"wrong.interface.token");
410 MessageParcel reply;
411 MessageOption option;
412 EXPECT_EQ(-1, callback->OnRemoteRequest(code, data, reply, option));
413 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 end");
414 }
415
416 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest004, TestSize.Level1)
417 {
418 GTEST_LOG_(INFO)
419 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest004, TestSize.Level1";
420 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest004 begin");
421 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
422 uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT_V9);
423 MessageParcel data;
424 data.WriteInterfaceToken(u"location.ILocatorCallback");
425 MessageParcel reply;
426 MessageOption option;
427 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
428 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest004 end");
429 }
430
431 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest005, TestSize.Level1)
432 {
433 GTEST_LOG_(INFO)
434 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest005, TestSize.Level1";
435 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest005 begin");
436 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
437 uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_ERROR_INFO_EVENT);
438 MessageParcel data;
439 data.WriteInterfaceToken(u"location.ILocatorCallback");
440 MessageParcel reply;
441 MessageOption option;
442 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
443 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest005 end");
444 }
445
446 HWTEST_F(NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1)
447 {
448 GTEST_LOG_(INFO)
449 << "NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1";
450 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 begin");
451 ability_->registerToAbility_ = false;
452 bool ret = ability_->Init(); // after mock, sa obj is nullptr
453 EXPECT_EQ(false, ret);
454
455 ability_->registerToAbility_ = true;
456 ret = ability_->Init();
457 EXPECT_EQ(true, ret);
458 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 end");
459 }
460
461 HWTEST_F(NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO)
464 << "NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1";
465 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 begin");
466 bool ret = ability_->ConnectNlpService();
467 EXPECT_EQ(false, ret);
468 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 end");
469 }
470
471 HWTEST_F(NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1)
472 {
473 GTEST_LOG_(INFO)
474 << "NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1";
475 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 begin");
476 bool ret = ability_->ReConnectNlpService();
477 EXPECT_EQ(false, ret);
478 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 end");
479 }
480
481 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1)
482 {
483 GTEST_LOG_(INFO)
484 << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1";
485 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 begin");
486 std::vector<std::shared_ptr<Location>> locations;
487 Parcel parcel;
488 parcel.WriteDouble(10.6); // latitude
489 parcel.WriteDouble(10.5); // longitude
490 parcel.WriteDouble(10.4); // altitude
491 parcel.WriteDouble(1.0); // accuracy
492 parcel.WriteDouble(5.0); // speed
493 parcel.WriteDouble(10); // direction
494 parcel.WriteInt64(1611000000); // timestamp
495 parcel.WriteInt64(1611000000); // time since boot
496 parcel.WriteString16(u"additions"); // additions
497 parcel.WriteInt64(1); // additionSize
498 parcel.WriteInt32(1); // isFromMock is true
499 locations.push_back(Location::UnmarshallingShared(parcel));
500 ability_->ProcessReportLocationMock();
501 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 end");
502 }
503
504 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock002, TestSize.Level1)
505 {
506 GTEST_LOG_(INFO)
507 << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock002, TestSize.Level1";
508 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock002 begin");
509 std::vector<std::shared_ptr<Location>> locations;
510 Parcel parcel;
511 parcel.WriteDouble(10.6); // latitude
512 parcel.WriteDouble(10.5); // longitude
513 parcel.WriteDouble(10.4); // altitude
514 parcel.WriteDouble(1.0); // accuracy
515 parcel.WriteDouble(5.0); // speed
516 parcel.WriteDouble(10); // direction
517 parcel.WriteInt64(1611000000); // timestamp
518 parcel.WriteInt64(1611000000); // time since boot
519 parcel.WriteString16(u"additions"); // additions
520 parcel.WriteInt64(1); // additionSize
521 parcel.WriteInt32(1); // isFromMock is true
522 locations.push_back(Location::UnmarshallingShared(parcel));
523 ability_->CacheLocationMock(locations);
524 ability_->ProcessReportLocationMock();
525 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock002 end");
526 }
527
528 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO)
531 << "NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1";
532 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 begin");
533
534 ability_->SendReportMockLocationEvent();
535 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 end");
536 }
537
538 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendMessage001, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO)
541 << "NetworkAbilityStubTest, NetworkAbilitySendMessage001, TestSize.Level1";
542 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 begin");
543 MessageParcel requestParcel;
544 requestParcel.WriteInterfaceToken(u"location.INetworkAbility");
545 requestParcel.WriteBuffer("data", 4);
546 requestParcel.RewindRead(0);
547
548 MessageParcel reply;
549
550 ability_->SendMessage(0, requestParcel, reply);
551 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 end");
552 }
553
554 HWTEST_F(NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1)
555 {
556 GTEST_LOG_(INFO)
557 << "NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1";
558 LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 begin");
559 EXPECT_EQ(true, ability_->ResetServiceProxy()); // Connect success
560 LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 end");
561 }
562
563 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO)
566 << "NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1";
567 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 begin");
568 auto workRecord = std::make_shared<WorkRecord>();
569 sptr<MockIRemoteObject> nlpServiceProxy =
570 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
571 EXPECT_NE(nullptr, nlpServiceProxy);
572 ability_->nlpServiceProxy_ = nlpServiceProxy;
573 std::shared_ptr<Request> request = std::make_shared<Request>();
574 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
575 requestConfig->SetTimeInterval(0);
576 request->SetUid(1);
577 request->SetPid(2);
578 request->SetPackageName("nameForTest");
579 request->SetRequestConfig(*requestConfig);
580 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
581 request->SetNlpRequestType(1);
582 workRecord->Add(request);
583 ability_->RequestNetworkLocation(*workRecord);
584 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 end");
585 }
586
587 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1)
588 {
589 GTEST_LOG_(INFO)
590 << "NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1";
591 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 begin");
592 auto workRecord = std::make_shared<WorkRecord>();
593 sptr<MockIRemoteObject> nlpServiceProxy =
594 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
595 EXPECT_NE(nullptr, nlpServiceProxy);
596 ability_->nlpServiceProxy_ = nlpServiceProxy;
597 std::shared_ptr<Request> request = std::make_shared<Request>();
598 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
599 requestConfig->SetTimeInterval(0);
600 request->SetUid(1);
601 request->SetPid(2);
602 request->SetPackageName("nameForTest");
603 request->SetRequestConfig(*requestConfig);
604 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
605 request->SetNlpRequestType(1);
606 workRecord->Add(request);
607 ability_->RemoveNetworkLocation(*workRecord);
608 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 end");
609 }
610
611 #ifdef FEATURE_PASSIVE_SUPPORT
612 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
613 {
614 GTEST_LOG_(INFO)
615 << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
616 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
617 std::vector<std::shared_ptr<Location>> locations;
618 Parcel parcel;
619 parcel.WriteDouble(10.6); // latitude
620 parcel.WriteDouble(10.5); // longitude
621 parcel.WriteDouble(10.4); // altitude
622 parcel.WriteDouble(1.0); // accuracy
623 parcel.WriteDouble(5.0); // speed
624 parcel.WriteDouble(10); // direction
625 parcel.WriteInt64(1611000000); // timestamp
626 parcel.WriteInt64(1611000000); // time since boot
627 parcel.WriteString16(u"additions"); // additions
628 parcel.WriteInt64(1); // additionSize
629 parcel.WriteInt32(1); // isFromMock is true
630 locations.push_back(Location::UnmarshallingShared(parcel));
631 ability_->ReportMockedLocation(locations);
632 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
633 }
634 #endif
635
636 HWTEST_F(NetworkAbilityTest, RegisterNlpServiceDeathRecipient001, TestSize.Level1)
637 {
638 GTEST_LOG_(INFO)
639 << "NetworkAbilityTest, RegisterNlpServiceDeathRecipient001, TestSize.Level1";
640 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient001 begin");
641 ability_->RegisterNlpServiceDeathRecipient();
642 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient001 end");
643 }
644
645 HWTEST_F(NetworkAbilityTest, ReportLocationError001, TestSize.Level1)
646 {
647 GTEST_LOG_(INFO)
648 << "NetworkAbilityTest, ReportLocationError001, TestSize.Level1";
649 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 begin");
650 ability_->ReportLocationError(0, "", "");
651 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 end");
652 }
653
654 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO)
657 << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
658 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
659 std::shared_ptr<Location> location = std::make_shared<Location>();
660 ability_->ReportMockedLocation(location);
661 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
662 }
663
664 HWTEST_F(NetworkAbilityTest, OnRemoteDied001, TestSize.Level1)
665 {
666 GTEST_LOG_(INFO)
667 << "NetworkAbilityTest, OnRemoteDied001, TestSize.Level1";
668 LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 begin");
669 auto deathRecipient = new (std::nothrow) NlpServiceDeathRecipient();
670 const wptr<IRemoteObject> object;
671 deathRecipient->OnRemoteDied(object);
672 LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 end");
673 }
674
675 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1)
676 {
677 GTEST_LOG_(INFO)
678 << "NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1";
679 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 begin");
680 ability_->state_ = ServiceRunningState::STATE_RUNNING;
681 ability_->OnStart(); // start ability
682 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 end");
683 }
684
685 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1)
686 {
687 GTEST_LOG_(INFO)
688 << "NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1";
689 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 begin");
690 sptr<MockIRemoteObject> nlpServiceProxy =
691 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
692 EXPECT_NE(nullptr, nlpServiceProxy);
693 ability_->nlpServiceProxy_ = nlpServiceProxy;
694 ability_->ConnectNlpService();
695 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 end");
696 }
697
698 HWTEST_F(NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO)
701 << "NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1";
702 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 begin");
703 sptr<MockIRemoteObject> nlpServiceProxy =
704 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
705 EXPECT_NE(nullptr, nlpServiceProxy);
706 ability_->nlpServiceProxy_ = nlpServiceProxy;
707 ability_->ReConnectNlpService(); // Connect success
708 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 end");
709 }
710
711 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1)
712 {
713 GTEST_LOG_(INFO)
714 << "NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1";
715 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 begin");
716 /*
717 * @tc.steps: step1.remove SA
718 * @tc.expected: step1. object1 is null.
719 */
720
721 ability_->SetEnable(false); // after mock, sa obj is nullptr
722 /*
723 * @tc.steps: step2. test enable SA
724 * @tc.expected: step2. object2 is not null.
725 */
726 ability_->SetEnable(true); // after mock, sa obj is nullptr
727 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 end");
728 }
729
730 HWTEST_F(NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1)
731 {
732 GTEST_LOG_(INFO)
733 << "NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1";
734 LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 begin");
735
736 ability_->UnloadNetworkSystemAbility();
737 LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 end");
738 }
739
740 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1)
741 {
742 GTEST_LOG_(INFO)
743 << "NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1";
744 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 begin");
745 ability_->nlpServiceProxy_ = nullptr;
746 WorkRecord workRecord;
747 EXPECT_EQ(false, ability_->RequestNetworkLocation(workRecord));
748 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 end");
749 }
750
751 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1)
752 {
753 GTEST_LOG_(INFO)
754 << "NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1";
755 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 begin");
756 ability_->nlpServiceProxy_ = nullptr;
757 WorkRecord workRecord;
758 EXPECT_EQ(false, ability_->RemoveNetworkLocation(workRecord));
759 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 end");
760 }
761
762 HWTEST_F(NetworkAbilityTest, RegisterNlpServiceDeathRecipient002, TestSize.Level1)
763 {
764 GTEST_LOG_(INFO)
765 << "NetworkAbilityTest, RegisterNlpServiceDeathRecipient002, TestSize.Level1";
766 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient002 begin");
767 sptr<MockIRemoteObject> nlpServiceProxy =
768 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
769 EXPECT_NE(nullptr, nlpServiceProxy);
770 ability_->nlpServiceProxy_ = nlpServiceProxy;
771 ability_->RegisterNlpServiceDeathRecipient();
772 ability_->UnregisterNlpServiceDeathRecipient();
773 ability_->UnregisterNlpServiceDeathRecipient();
774 ability_->RegisterNlpServiceDeathRecipient();
775 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNlpServiceDeathRecipient002 end");
776 }
777
778 HWTEST_F(NetworkAbilityTest, InitNetworkEventProcessMap001, TestSize.Level1)
779 {
780 GTEST_LOG_(INFO)
781 << "NetworkAbilityTest, InitNetworkEventProcessMap001, TestSize.Level1";
782 LBSLOGI(NETWORK, "[NetworkAbilityTest] InitNetworkEventProcessMap001 begin");
783 ASSERT_TRUE(ability_ != nullptr);
784 ASSERT_TRUE(ability_->networkHandler_ != nullptr);
785 ability_->networkHandler_->InitNetworkEventProcessMap();
786 ability_->networkHandler_->InitNetworkEventProcessMap();
787 LBSLOGI(NETWORK, "[NetworkAbilityTest] InitNetworkEventProcessMap001 end");
788 }
789
790 HWTEST_F(NetworkAbilityTest, CheckLocationSwitchState001, TestSize.Level1)
791 {
792 GTEST_LOG_(INFO)
793 << "NetworkAbilityTest, CheckLocationSwitchState001, TestSize.Level1";
794 LBSLOGI(NETWORK, "[NetworkAbilityTest] CheckLocationSwitchState001 begin");
795 MessageParcel reply;
796 ASSERT_TRUE(ability_ != nullptr);
797 ability_->CheckLocationSwitchState(reply);
798 LBSLOGI(NETWORK, "[NetworkAbilityTest] CheckLocationSwitchState001 end");
799 }
800
801 HWTEST_F(NetworkAbilityTest, InitNetworkMsgHandleMap001, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO)
804 << "NetworkAbilityTest, InitNetworkMsgHandleMap001, TestSize.Level1";
805 LBSLOGI(NETWORK, "[NetworkAbilityTest] InitNetworkMsgHandleMap001 begin");
806 MessageParcel reply;
807 ASSERT_TRUE(ability_ != nullptr);
808 ability_->InitNetworkMsgHandleMap();
809 ability_->InitNetworkMsgHandleMap();
810 LBSLOGI(NETWORK, "[NetworkAbilityTest] InitNetworkMsgHandleMap001 end");
811 }
812
813 HWTEST_F(NetworkAbilityTest, CheckCallingPermission001, TestSize.Level1)
814 {
815 GTEST_LOG_(INFO)
816 << "NetworkAbilityTest, CheckCallingPermission001, TestSize.Level1";
817 LBSLOGI(NETWORK, "[NetworkAbilityTest] CheckCallingPermission001 begin");
818 MessageParcel data;
819 MessageParcel reply;
820 AppIdentity identity;
821 ASSERT_TRUE(ability_ != nullptr);
822 ability_->SendLocationRequestInner(data, reply, identity);
823 ability_->SetMockLocationsInner(data, reply, identity);
824 ability_->SetEnableInner(data, reply, identity);
825 ability_->EnableMockInner(data, reply, identity);
826 ability_->DisableMockInner(data, reply, identity);
827 LBSLOGI(NETWORK, "[NetworkAbilityTest] CheckCallingPermission001 end");
828 }
829
830 HWTEST_F(NetworkAbilityTest, DisconnectAbilityConnect001, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO)
833 << "NetworkAbilityTest, DisconnectAbilityConnect001, TestSize.Level1";
834 LBSLOGI(NETWORK, "[NetworkAbilityTest] DisconnectAbilityConnect001 begin");
835 sptr<MockIRemoteObject> nlpServiceProxy =
836 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
837 EXPECT_NE(nullptr, nlpServiceProxy);
838 ability_->nlpServiceProxy_ = nlpServiceProxy;
839 ability_->DisconnectAbilityConnect();
840 LBSLOGI(NETWORK, "[NetworkAbilityTest] DisconnectAbilityConnect001 end");
841 }
842
843 HWTEST_F(NetworkAbilityTest, NullHandler001, TestSize.Level1)
844 {
845 GTEST_LOG_(INFO)
846 << "NetworkAbilityTest, NullHandler001, TestSize.Level1";
847 LBSLOGI(NETWORK, "[NetworkAbilityTest] NullHandler001 begin");
848 ASSERT_TRUE(ability_ != nullptr);
849 ability_->networkHandler_ = nullptr;
850 ability_->ResetServiceProxy();
851 ability_->SetEnable(1);
852 ability_->UnloadNetworkSystemAbility();
853 ability_->SendReportMockLocationEvent();
854 uint32_t code = 0;
855 MessageParcel data;
856 MessageParcel reply;
857 ability_->SendMessage(code, data, reply);
858 ability_->networkHandler_ =
859 std::make_shared<NetworkHandler>(AppExecFwk::EventRunner::Create(true, AppExecFwk::ThreadMode::FFRT));
860 LBSLOGI(NETWORK, "[NetworkAbilityTest] NullHandler001 end");
861 }
862
863 HWTEST_F(NetworkAbilityTest, NullNlpServer001, TestSize.Level1)
864 {
865 GTEST_LOG_(INFO)
866 << "NetworkAbilityTest, NullNlpServer001, TestSize.Level1";
867 LBSLOGI(NETWORK, "[NetworkAbilityTest] NullNlpServer001 begin");
868 ASSERT_TRUE(ability_ != nullptr);
869 ability_->nlpServiceProxy_ = nullptr;
870 ability_->RegisterNlpServiceDeathRecipient();
871 ability_->UnregisterNlpServiceDeathRecipient();
872 sptr<MockIRemoteObject> nlpServiceProxy =
873 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
874 ability_->nlpServiceProxy_ = nlpServiceProxy;
875 LBSLOGI(NETWORK, "[NetworkAbilityTest] NullNlpServer001 end");
876 }
877 } // namespace Location
878 } // namespace OHOS
879 #endif // FEATURE_NETWORK_SUPPORT