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 = 4;
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 };
106 NativeTokenInfoParams infoInstance = {
107 .dcapsNum = 0,
108 .permsNum = LOCATION_PERM_NUM,
109 .aclsNum = 0,
110 .dcaps = nullptr,
111 .perms = perms,
112 .acls = nullptr,
113 .processName = "NetworkAbilityTest",
114 .aplStr = "system_basic",
115 };
116 uint64_t tokenId = GetAccessTokenId(&infoInstance);
117 SetSelfTokenID(tokenId);
118 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
119 }
120
121 /*
122 * @tc.name: SendLocationRequest001
123 * @tc.desc: Build Request, marshall and unmarshall data Then Send it
124 * @tc.type: FUNC
125 */
126 HWTEST_F(NetworkAbilityTest, SendLocationRequest001, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO)
129 << "NetworkAbilityTest, SendLocationRequest001, TestSize.Level1";
130 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 begin");
131 /*
132 * @tc.steps: step1. build location request data.
133 */
134 std::unique_ptr<WorkRecord> workRecord = std::make_unique<WorkRecord>();
135 int num = 2;
136 for (int i = 0; i < num; i++) {
137 std::shared_ptr<Request> request = std::make_shared<Request>();
138 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
139 requestConfig->SetTimeInterval(i);
140 request->SetUid(i + 1);
141 request->SetPid(i + 2);
142 request->SetPackageName("nameForTest");
143 request->SetRequestConfig(*requestConfig);
144 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
145 request->SetNlpRequestType(i + 1);
146 workRecord->Add(request);
147 }
148 /*
149 * @tc.steps: step2. send location request
150 * @tc.expected: step2. no exception happens.
151 */
152 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendLocationRequest(*workRecord));
153 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 end");
154 }
155
156 /*
157 * @tc.name: SetEnableAndDisable001
158 * @tc.desc: Test disable and enable system ability
159 * @tc.type: FUNC
160 */
161 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1)
162 {
163 GTEST_LOG_(INFO)
164 << "NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1";
165 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 begin");
166 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false));
167 /*
168 * @tc.steps: step1.remove SA
169 * @tc.expected: step1. object1 is null.
170 */
171 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false)); // after mock, sa obj is nullptr
172
173 /*
174 * @tc.steps: step2. test enable SA
175 * @tc.expected: step2. object2 is not null.
176 */
177 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(true)); // after mock, sa obj is nullptr
178 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 end");
179 }
180
181 HWTEST_F(NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO)
184 << "NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1";
185 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 begin");
186 int timeInterval = 1;
187 std::vector<std::shared_ptr<Location>> locations;
188 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->EnableMock());
189 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetMocked(timeInterval, locations));
190
191 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->DisableMock());
192 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->SetMocked(timeInterval, locations));
193 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 end");
194 }
195
196 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO)
199 << "NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1";
200 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 begin");
201 ability_->OnStart(); // start ability
202 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
203 (ServiceRunningState)ability_->QueryServiceState()); // after mock
204 ability_->OnStart(); // start ability again
205 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
206 (ServiceRunningState)ability_->QueryServiceState()); // after mock
207
208 ability_->OnStop(); // stop ability
209 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
210 (ServiceRunningState)ability_->QueryServiceState()); // after mock
211 ability_->OnStart(); // restart ability
212 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
213 (ServiceRunningState)ability_->QueryServiceState()); // after mock
214 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 end");
215 }
216
217 HWTEST_F(NetworkAbilityTest, NetworkDump001, TestSize.Level1)
218 {
219 GTEST_LOG_(INFO)
220 << "NetworkAbilityTest, NetworkDump001, TestSize.Level1";
221 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 begin");
222 int32_t fd = 0;
223 std::vector<std::u16string> args;
224 std::u16string arg1 = Str8ToStr16("arg1");
225 args.emplace_back(arg1);
226 std::u16string arg2 = Str8ToStr16("arg2");
227 args.emplace_back(arg2);
228 std::u16string arg3 = Str8ToStr16("arg3");
229 args.emplace_back(arg3);
230 std::u16string arg4 = Str8ToStr16("arg4");
231 args.emplace_back(arg4);
232 EXPECT_EQ(ERR_OK, ability_->Dump(fd, args));
233
234 std::vector<std::u16string> emptyArgs;
235 EXPECT_EQ(ERR_OK, ability_->Dump(fd, emptyArgs));
236
237 std::vector<std::u16string> helpArgs;
238 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
239 helpArgs.emplace_back(helpArg1);
240 EXPECT_EQ(ERR_OK, ability_->Dump(fd, helpArgs));
241 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 end");
242 }
243
244 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1)
245 {
246 GTEST_LOG_(INFO)
247 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1";
248 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 begin");
249 ability_->SendReportMockLocationEvent(); // clear location mock
250
251 int timeInterval = 0;
252 std::vector<std::shared_ptr<Location>> locations;
253 Parcel parcel;
254 parcel.WriteDouble(10.6); // latitude
255 parcel.WriteDouble(10.5); // longitude
256 parcel.WriteDouble(10.4); // altitude
257 parcel.WriteDouble(1.0); // accuracy
258 parcel.WriteDouble(5.0); // speed
259 parcel.WriteDouble(10); // direction
260 parcel.WriteInt64(1611000000); // timestamp
261 parcel.WriteInt64(1611000000); // time since boot
262 parcel.WriteString16(u"additions"); // additions
263 parcel.WriteInt64(1); // additionSize
264 parcel.WriteInt32(1); // isFromMock is true
265 locations.push_back(Location::UnmarshallingShared(parcel));
266 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
267 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
268 sleep(2);
269 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 end");
270 }
271
272 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1)
273 {
274 GTEST_LOG_(INFO)
275 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1";
276 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 begin");
277 ability_->SendReportMockLocationEvent(); // clear location mock
278
279 int timeInterval = 0;
280 std::vector<std::shared_ptr<Location>> locations;
281 Parcel parcel;
282 parcel.WriteDouble(10.6); // latitude
283 parcel.WriteDouble(10.5); // longitude
284 parcel.WriteDouble(10.4); // altitude
285 parcel.WriteDouble(1.0); // accuracy
286 parcel.WriteDouble(5.0); // speed
287 parcel.WriteDouble(10); // direction
288 parcel.WriteInt64(1611000000); // timestamp
289 parcel.WriteInt64(1611000000); // time since boot
290 parcel.WriteString16(u"additions"); // additions
291 parcel.WriteInt64(1); // additionSize
292 parcel.WriteInt32(0); // isFromMock is false
293 locations.push_back(Location::UnmarshallingShared(parcel));
294 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
295 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
296 sleep(2);
297 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 end");
298 }
299
300 /*
301 * @tc.name: NetworkConnectNlpService001
302 * @tc.desc: connect nlp service
303 * @tc.type: FUNC
304 */
305 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1)
306 {
307 GTEST_LOG_(INFO)
308 << "NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1";
309 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 begin");
310 EXPECT_EQ(false, ability_->ReConnectNlpService());
311 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 end");
312 }
313
314 HWTEST_F(NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO)
317 << "NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1";
318 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 begin");
319 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
320 EXPECT_EQ(false, ability->ReConnectNlpService()); // Connect success
321 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 end");
322 }
323
324 HWTEST_F(NetworkAbilityTest, NotifyConnected001, TestSize.Level1)
325 {
326 GTEST_LOG_(INFO)
327 << "NetworkAbilityTest, NotifyConnected001, TestSize.Level1";
328 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 begin");
329 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
330 sptr<IRemoteObject> obj = nullptr;
331 ability->NotifyConnected(obj);
332 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
333
334 ability->NotifyDisConnected();
335 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
336 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 end");
337 }
338
339 HWTEST_F(NetworkAbilityTest, SendLocationRequest002, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO)
342 << "NetworkAbilityTest, SendLocationRequest002, TestSize.Level1";
343 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 begin");
344 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
345 WorkRecord workRecord;
346 ability->SendLocationRequest(workRecord);
347 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 end");
348 }
349
350 HWTEST_F(NetworkAbilityTest, RequestRecord001, TestSize.Level1)
351 {
352 GTEST_LOG_(INFO)
353 << "NetworkAbilityTest, RequestRecord001, TestSize.Level1";
354 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 begin");
355 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
356 WorkRecord workRecord;
357 ability->RequestRecord(workRecord, true);
358
359 ability->RequestRecord(workRecord, false);
360 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 end");
361 }
362
363 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1)
364 {
365 GTEST_LOG_(INFO)
366 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1";
367 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 begin");
368 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
369 uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT);
370 MessageParcel data;
371 data.WriteInterfaceToken(u"location.ILocatorCallback");
372 MessageParcel reply;
373 MessageOption option;
374 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
375 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 end");
376 }
377
378 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO)
381 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1";
382 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 begin");
383 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
384 uint32_t code = 0;
385 MessageParcel data;
386 data.WriteInterfaceToken(u"location.ILocatorCallback");
387 MessageParcel reply;
388 MessageOption option;
389 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
390 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 end");
391 }
392
393 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1)
394 {
395 GTEST_LOG_(INFO)
396 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1";
397 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 begin");
398 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
399 uint32_t code = 0;
400 MessageParcel data;
401 data.WriteInterfaceToken(u"wrong.interface.token");
402 MessageParcel reply;
403 MessageOption option;
404 EXPECT_EQ(-1, callback->OnRemoteRequest(code, data, reply, option));
405 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 end");
406 }
407
408 HWTEST_F(NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1)
409 {
410 GTEST_LOG_(INFO)
411 << "NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1";
412 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 begin");
413 ability_->registerToAbility_ = false;
414 bool ret = ability_->Init(); // after mock, sa obj is nullptr
415 EXPECT_EQ(false, ret);
416
417 ability_->registerToAbility_ = true;
418 ret = ability_->Init();
419 EXPECT_EQ(true, ret);
420 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 end");
421 }
422
423 HWTEST_F(NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1)
424 {
425 GTEST_LOG_(INFO)
426 << "NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1";
427 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 begin");
428 bool ret = ability_->ConnectNlpService();
429 EXPECT_EQ(false, ret);
430 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 end");
431 }
432
433 HWTEST_F(NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1)
434 {
435 GTEST_LOG_(INFO)
436 << "NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1";
437 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 begin");
438 bool ret = ability_->ReConnectNlpService();
439 EXPECT_EQ(false, ret);
440 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 end");
441 }
442
443 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1)
444 {
445 GTEST_LOG_(INFO)
446 << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1";
447 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 begin");
448 ability_->mockLocationIndex_ = -1;
449
450 std::vector<std::shared_ptr<Location>> locations;
451 Parcel parcel;
452 parcel.WriteDouble(10.6); // latitude
453 parcel.WriteDouble(10.5); // longitude
454 parcel.WriteDouble(10.4); // altitude
455 parcel.WriteDouble(1.0); // accuracy
456 parcel.WriteDouble(5.0); // speed
457 parcel.WriteDouble(10); // direction
458 parcel.WriteInt64(1611000000); // timestamp
459 parcel.WriteInt64(1611000000); // time since boot
460 parcel.WriteString16(u"additions"); // additions
461 parcel.WriteInt64(1); // additionSize
462 parcel.WriteInt32(1); // isFromMock is true
463 locations.push_back(Location::UnmarshallingShared(parcel));
464 ability_->CacheLocationMock(locations);
465 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 end");
466 }
467
468 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1)
469 {
470 GTEST_LOG_(INFO)
471 << "NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1";
472 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 begin");
473
474 ability_->SendReportMockLocationEvent();
475 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 end");
476 }
477
478 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendMessage001, TestSize.Level1)
479 {
480 GTEST_LOG_(INFO)
481 << "NetworkAbilityStubTest, NetworkAbilitySendMessage001, TestSize.Level1";
482 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 begin");
483 MessageParcel requestParcel;
484 requestParcel.WriteInterfaceToken(u"location.INetworkAbility");
485 requestParcel.WriteBuffer("data", 4);
486 requestParcel.RewindRead(0);
487
488 MessageParcel reply;
489
490 ability_->SendMessage(0, requestParcel, reply);
491 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 end");
492 }
493
494 HWTEST_F(NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1)
495 {
496 GTEST_LOG_(INFO)
497 << "NetworkAbilityTest, ResetServiceProxy001, TestSize.Level1";
498 LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 begin");
499 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
500 EXPECT_EQ(true, ability->ResetServiceProxy()); // Connect success
501 LBSLOGI(NETWORK, "[NetworkAbilityTest] ResetServiceProxy001 end");
502 }
503
504 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1)
505 {
506 GTEST_LOG_(INFO)
507 << "NetworkAbilityTest, RequestNetworkLocation001, TestSize.Level1";
508 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 begin");
509 auto workRecord = std::make_shared<WorkRecord>();
510 sptr<MockIRemoteObject> nlpServiceProxy =
511 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
512 EXPECT_NE(nullptr, nlpServiceProxy);
513 ability_->nlpServiceProxy_ = nlpServiceProxy;
514 std::shared_ptr<Request> request = std::make_shared<Request>();
515 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
516 requestConfig->SetTimeInterval(0);
517 request->SetUid(1);
518 request->SetPid(2);
519 request->SetPackageName("nameForTest");
520 request->SetRequestConfig(*requestConfig);
521 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
522 request->SetNlpRequestType(1);
523 workRecord->Add(request);
524 ability_->RequestNetworkLocation(*workRecord);
525 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation001 end");
526 }
527
528 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO)
531 << "NetworkAbilityTest, RemoveNetworkLocation001, TestSize.Level1";
532 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 begin");
533 auto workRecord = std::make_shared<WorkRecord>();
534 sptr<MockIRemoteObject> nlpServiceProxy =
535 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
536 EXPECT_NE(nullptr, nlpServiceProxy);
537 ability_->nlpServiceProxy_ = nlpServiceProxy;
538 std::shared_ptr<Request> request = std::make_shared<Request>();
539 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
540 requestConfig->SetTimeInterval(0);
541 request->SetUid(1);
542 request->SetPid(2);
543 request->SetPackageName("nameForTest");
544 request->SetRequestConfig(*requestConfig);
545 request->SetUuid(std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM)));
546 request->SetNlpRequestType(1);
547 workRecord->Add(request);
548 ability_->RemoveNetworkLocation(*workRecord);
549 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation001 end");
550 }
551
552 #ifdef FEATURE_PASSIVE_SUPPORT
553 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
554 {
555 GTEST_LOG_(INFO)
556 << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
557 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
558 std::vector<std::shared_ptr<Location>> locations;
559 Parcel parcel;
560 parcel.WriteDouble(10.6); // latitude
561 parcel.WriteDouble(10.5); // longitude
562 parcel.WriteDouble(10.4); // altitude
563 parcel.WriteDouble(1.0); // accuracy
564 parcel.WriteDouble(5.0); // speed
565 parcel.WriteDouble(10); // direction
566 parcel.WriteInt64(1611000000); // timestamp
567 parcel.WriteInt64(1611000000); // time since boot
568 parcel.WriteString16(u"additions"); // additions
569 parcel.WriteInt64(1); // additionSize
570 parcel.WriteInt32(1); // isFromMock is true
571 locations.push_back(Location::UnmarshallingShared(parcel));
572 ability_->ReportMockedLocation(locations);
573 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
574 }
575 #endif
576
577 HWTEST_F(NetworkAbilityTest, RegisterNLPServiceDeathRecipient001, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO)
580 << "NetworkAbilityTest, RegisterNLPServiceDeathRecipient001, TestSize.Level1";
581 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNLPServiceDeathRecipient001 begin");
582 ability_->RegisterNLPServiceDeathRecipient();
583 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNLPServiceDeathRecipient001 end");
584 }
585
586 HWTEST_F(NetworkAbilityTest, ReportLocationError001, TestSize.Level1)
587 {
588 GTEST_LOG_(INFO)
589 << "NetworkAbilityTest, ReportLocationError001, TestSize.Level1";
590 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 begin");
591 ability_->ReportLocationError(0, "", "");
592 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportLocationError001 end");
593 }
594
595 HWTEST_F(NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1)
596 {
597 GTEST_LOG_(INFO)
598 << "NetworkAbilityTest, ReportMockedLocation001, TestSize.Level1";
599 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 begin");
600 std::shared_ptr<Location> location = std::make_shared<Location>();
601 ability_->ReportMockedLocation(location);
602 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReportMockedLocation001 end");
603 }
604
605 HWTEST_F(NetworkAbilityTest, OnRemoteDied001, TestSize.Level1)
606 {
607 GTEST_LOG_(INFO)
608 << "NetworkAbilityTest, OnRemoteDied001, TestSize.Level1";
609 LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 begin");
610 auto deathRecipient = new (std::nothrow) NLPServiceDeathRecipient();
611 const wptr<IRemoteObject> object;
612 deathRecipient->OnRemoteDied(object);
613 LBSLOGI(NETWORK, "[NetworkAbilityTest] OnRemoteDied001 end");
614 }
615
616 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1)
617 {
618 GTEST_LOG_(INFO)
619 << "NetworkAbilityTest, NetworkOnStartAndOnStop002, TestSize.Level1";
620 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 begin");
621 ability_->state_ = ServiceRunningState::STATE_RUNNING;
622 ability_->OnStart(); // start ability
623 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop002 end");
624 }
625
626 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1)
627 {
628 GTEST_LOG_(INFO)
629 << "NetworkAbilityTest, NetworkConnectNlpService002, TestSize.Level1";
630 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 begin");
631 sptr<MockIRemoteObject> nlpServiceProxy =
632 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
633 EXPECT_NE(nullptr, nlpServiceProxy);
634 ability_->nlpServiceProxy_ = nlpServiceProxy;
635 ability_->ConnectNlpService();
636 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService002 end");
637 }
638
639 HWTEST_F(NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1)
640 {
641 GTEST_LOG_(INFO)
642 << "NetworkAbilityTest, ReConnectNlpService002, TestSize.Level1";
643 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 begin");
644 sptr<MockIRemoteObject> nlpServiceProxy =
645 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
646 EXPECT_NE(nullptr, nlpServiceProxy);
647 ability_->nlpServiceProxy_ = nlpServiceProxy;
648 ability_->ReConnectNlpService(); // Connect success
649 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService002 end");
650 }
651
652 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1)
653 {
654 GTEST_LOG_(INFO)
655 << "NetworkAbilityTest, SetEnableAndDisable002, TestSize.Level1";
656 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 begin");
657 /*
658 * @tc.steps: step1.remove SA
659 * @tc.expected: step1. object1 is null.
660 */
661
662 ability_->SetEnable(false); // after mock, sa obj is nullptr
663 /*
664 * @tc.steps: step2. test enable SA
665 * @tc.expected: step2. object2 is not null.
666 */
667 ability_->SetEnable(true); // after mock, sa obj is nullptr
668 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable002 end");
669 }
670
671 HWTEST_F(NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1)
672 {
673 GTEST_LOG_(INFO)
674 << "NetworkAbilityTest, UnloadNetworkSystemAbility001, TestSize.Level1";
675 LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 begin");
676
677 ability_->UnloadNetworkSystemAbility();
678 LBSLOGI(NETWORK, "[NetworkAbilityTest] UnloadNetworkSystemAbility001 end");
679 }
680
681 HWTEST_F(NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1)
682 {
683 GTEST_LOG_(INFO)
684 << "NetworkAbilityTest, RequestNetworkLocation002, TestSize.Level1";
685 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 begin");
686 ability_->nlpServiceProxy_ = nullptr;
687 WorkRecord workRecord;
688 EXPECT_EQ(false, ability_->RequestNetworkLocation(workRecord));
689 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestNetworkLocation002 end");
690 }
691
692 HWTEST_F(NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1)
693 {
694 GTEST_LOG_(INFO)
695 << "NetworkAbilityTest, RemoveNetworkLocation002, TestSize.Level1";
696 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 begin");
697 ability_->nlpServiceProxy_ = nullptr;
698 WorkRecord workRecord;
699 EXPECT_EQ(false, ability_->RemoveNetworkLocation(workRecord));
700 LBSLOGI(NETWORK, "[NetworkAbilityTest] RemoveNetworkLocation002 end");
701 }
702
703 HWTEST_F(NetworkAbilityTest, RegisterNLPServiceDeathRecipient002, TestSize.Level1)
704 {
705 GTEST_LOG_(INFO)
706 << "NetworkAbilityTest, RegisterNLPServiceDeathRecipient002, TestSize.Level1";
707 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNLPServiceDeathRecipient002 begin");
708 sptr<MockIRemoteObject> nlpServiceProxy =
709 sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
710 EXPECT_NE(nullptr, nlpServiceProxy);
711 ability_->nlpServiceProxy_ = nlpServiceProxy;
712 ability_->RegisterNLPServiceDeathRecipient();
713 LBSLOGI(NETWORK, "[NetworkAbilityTest] RegisterNLPServiceDeathRecipient002 end");
714 }
715 } // namespace Location
716 } // namespace OHOS
717 #endif // FEATURE_NETWORK_SUPPORT