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 #include "locator_service_test.h"
17
18 #include <cstdlib>
19
20 #include "accesstoken_kit.h"
21 #include "bundle_mgr_interface.h"
22 #include "bundle_mgr_proxy.h"
23 #include "if_system_ability_manager.h"
24 #include "ipc_skeleton.h"
25 #include "iservice_registry.h"
26 #include "nativetoken_kit.h"
27 #include "system_ability_definition.h"
28 #include "token_setproc.h"
29
30 #include "app_identity.h"
31 #ifdef FEATURE_GNSS_SUPPORT
32 #include "cached_locations_callback_napi.h"
33 #endif
34 #include "common_utils.h"
35 #include "constant_definition.h"
36 #include "country_code.h"
37 #include "country_code_callback_napi.h"
38 #ifdef FEATURE_GEOCODE_SUPPORT
39 #include "geo_address.h"
40 #include "geocode_convert_address_request.h"
41 #include "geocode_convert_location_request.h"
42 #include "geo_convert_callback_host.h"
43 #endif
44 #ifdef FEATURE_GNSS_SUPPORT
45 #include "gnss_status_callback_napi.h"
46 #endif
47 #include "ilocator_service.h"
48 #include "location.h"
49 #include "location_log.h"
50 #include "location_sa_load_manager.h"
51 #include "location_switch_callback_napi.h"
52 #include "locator.h"
53 #include "locator_callback_napi.h"
54 #include "locator_callback_proxy.h"
55 #define private public
56 #undef private
57 #ifdef FEATURE_GNSS_SUPPORT
58 #include "nmea_message_callback_napi.h"
59 #endif
60 #include "permission_manager.h"
61 #include "geofence_request.h"
62 #include "location_data_rdb_manager.h"
63 #include "mock_i_remote_object.h"
64 #include "proxy_freeze_manager.h"
65
66 using namespace testing::ext;
67
68 namespace OHOS {
69 namespace Location {
70 const int32_t LOCATION_PERM_NUM = 6;
71 #ifdef FEATURE_GEOCODE_SUPPORT
72 const double MOCK_LATITUDE = 99.0;
73 const double MOCK_LONGITUDE = 100.0;
74 #endif
75 const int REQUEST_MAX_NUM = 3;
76 const int UNKNOWN_SERVICE_ID = -1;
77 const int GET_SWITCH_STATE = 1;
78 const int DISABLED_SWITCHMODE = 0;
79 const int ENABLED_SWITCHMODE = 1;
80 const int DEFAULT_SWITCHMODE = 2;
81 const std::string ARGS_HELP = "-h";
82 const std::string RUNNING_STATE_OBSERVER = "ohos.permission.RUNNING_STATE_OBSERVER";
SetUp()83 void LocatorServiceTest::SetUp()
84 {
85 /*
86 * @tc.setup: Get system ability's pointer and get sa proxy object.
87 */
88 MockNativePermission();
89 callbackStub_ = new (std::nothrow) LocatorCallbackStub();
90 EXPECT_NE(nullptr, callbackStub_);
91 backgroundProxy_ = LocatorBackgroundProxy::GetInstance();
92 EXPECT_NE(nullptr, backgroundProxy_);
93 request_ = std::make_shared<Request>();
94 EXPECT_NE(nullptr, request_);
95 request_->SetLocatorCallBack(callbackStub_);
96 request_->SetUid(SYSTEM_UID);
97 request_->SetPid(getpid());
98 SetStartUpConfirmed(true);
99 ChangedLocationMode(true);
100 }
101
TearDown()102 void LocatorServiceTest::TearDown()
103 {
104 /*
105 * @tc.teardown: release memory.
106 */
107 callbackStub_ = nullptr;
108 backgroundProxy_ = nullptr;
109 }
110
LoadSystemAbility()111 void LocatorServiceTest::LoadSystemAbility()
112 {
113 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_LOCATOR_SA_ID);
114 #ifdef FEATURE_GNSS_SUPPORT
115 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_GNSS_SA_ID);
116 #endif
117 #ifdef FEATURE_PASSIVE_SUPPORT
118 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_NOPOWER_LOCATING_SA_ID);
119 #endif
120 #ifdef FEATURE_NETWORK_SUPPORT
121 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_NETWORK_LOCATING_SA_ID);
122 #endif
123 #ifdef FEATURE_GEOCODE_SUPPORT
124 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_GEO_CONVERT_SA_ID);
125 #endif
126 }
127
MockNativePermission()128 void LocatorServiceTest::MockNativePermission()
129 {
130 const char *perms[] = {
131 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
132 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
133 RUNNING_STATE_OBSERVER.c_str(), ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
134 ACCESS_MOCK_LOCATION.c_str(), RSS_PROCESS_NAME.c_str()
135 };
136 NativeTokenInfoParams infoInstance = {
137 .dcapsNum = 0,
138 .permsNum = 8,
139 .aclsNum = 0,
140 .dcaps = nullptr,
141 .perms = perms,
142 .acls = nullptr,
143 .processName = "LocatorTest",
144 .aplStr = "system_basic",
145 };
146 tokenId_ = GetAccessTokenId(&infoInstance);
147 SetSelfTokenID(tokenId_);
148 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
149 }
150
SetStartUpConfirmed(bool isAuthorized)151 void LocatorServiceTest::SetStartUpConfirmed(bool isAuthorized)
152 {
153 std::string value = isAuthorized ? "1" : "0";
154 std::string executeCmd = "settings put SECURE high_accuracy_startup_comfirm " + value;
155 system(executeCmd.c_str());
156 }
157
ChangedLocationMode(bool isEnable)158 void LocatorServiceTest::ChangedLocationMode(bool isEnable)
159 {
160 std::string value = isEnable ? "3" : "0";
161 std::string executeCmd = "settings put SECURE location_mode " + value;
162 system(executeCmd.c_str());
163 }
164
165 #ifdef FEATURE_GEOCODE_SUPPORT
SetGeocodingMockInfo()166 std::vector<std::shared_ptr<GeocodingMockInfo>> LocatorServiceTest::SetGeocodingMockInfo()
167 {
168 std::vector<std::shared_ptr<GeocodingMockInfo>> geoMockInfos;
169 std::shared_ptr<GeocodingMockInfo> geocodingMockInfo =
170 std::make_shared<GeocodingMockInfo>();
171 MessageParcel parcel;
172 parcel.WriteString16(Str8ToStr16("locale"));
173 parcel.WriteDouble(MOCK_LATITUDE); // latitude
174 parcel.WriteDouble(MOCK_LONGITUDE); // longitude
175 parcel.WriteInt32(1);
176 parcel.WriteString("localeLanguage");
177 parcel.WriteString("localeCountry");
178 parcel.WriteInt32(1); // size
179 parcel.WriteInt32(0); // line
180 parcel.WriteString("line");
181 parcel.WriteString("placeName");
182 parcel.WriteString("administrativeArea");
183 parcel.WriteString("subAdministrativeArea");
184 parcel.WriteString("locality");
185 parcel.WriteString("subLocality");
186 parcel.WriteString("roadName");
187 parcel.WriteString("subRoadName");
188 parcel.WriteString("premises");
189 parcel.WriteString("postalCode");
190 parcel.WriteString("countryCode");
191 parcel.WriteString("countryName");
192 parcel.WriteInt32(1); // hasLatitude
193 parcel.WriteDouble(MOCK_LATITUDE); // latitude
194 parcel.WriteInt32(1); // hasLongitude
195 parcel.WriteDouble(MOCK_LONGITUDE); // longitude
196 parcel.WriteString("phoneNumber");
197 parcel.WriteString("addressUrl");
198 parcel.WriteBool(true);
199 geocodingMockInfo->ReadFromParcel(parcel);
200 geoMockInfos.emplace_back(std::move(geocodingMockInfo));
201 return geoMockInfos;
202 }
203 #endif
204
205 /*
206 * @tc.name: IsCallbackInProxyTest001
207 * @tc.desc: Check if callback is in the proxy callback list
208 * @tc.type: FUNC
209 */
210 HWTEST_F(LocatorServiceTest, IsCallbackInProxyTest001, TestSize.Level0)
211 {
212 /*
213 * @tc.steps: step1. Check if callback is in the proxy callback list
214 * @tc.expected: step1. return false
215 */
216 GTEST_LOG_(INFO)
217 << "LocatorServiceTest, IsCallbackInProxyTest001, TestSize.Level0";
218 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsCallbackInProxyTest001 begin");
219 bool result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
220 EXPECT_EQ(false, result);
221 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsCallbackInProxyTest001 end");
222 }
223
224 /*
225 * @tc.name: OnSuspendTest001
226 * @tc.desc: Test the function of the process enter and exit frozen state
227 * @tc.type: FUNC
228 */
229 HWTEST_F(LocatorServiceTest, OnSuspendTest001, TestSize.Level1)
230 {
231 /*
232 * @tc.steps: step1. Call the onsuspend function, the process enter frozen state
233 * @tc.expected: step1. return true, the callback of the process is in the proxy list
234 * @tc.steps: step2. Call the onsuspend function, the process exit frozen state
235 * @tc.expected: step2. return false, the callback of the process is remove from the proxy list
236 */
237 GTEST_LOG_(INFO)
238 << "LocatorServiceTest, OnSuspendTest001, TestSize.Level1";
239 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnSuspendTest001 begin");
240 backgroundProxy_->OnSuspend(request_, 0);
241 bool result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
242 // no location permission
243 EXPECT_EQ(false, result);
244 backgroundProxy_->OnSuspend(request_, 1);
245 result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
246 EXPECT_EQ(false, result);
247 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnSuspendTest001 end");
248 }
249
250 /*
251 * @tc.name: OnPermissionChanged001
252 * @tc.desc: Test the function onPermissionChanged and OnDeleteRequestRecord
253 * @tc.type: FUNC
254 */
255 HWTEST_F(LocatorServiceTest, OnPermissionChanged001, TestSize.Level1)
256 {
257 /*
258 * @tc.steps: step1. Call the onsuspend function, the process enter frozen state
259 * @tc.steps: step2. Call onPermissionChanged, the process exit frozen state
260 * @tc.expected: step2. return true, the callback of the process is in the proxy list
261 */
262 GTEST_LOG_(INFO)
263 << "LocatorServiceTest, OnPermissionChanged001, TestSize.Level1";
264 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnPermissionChanged001 begin");
265 backgroundProxy_->OnSuspend(request_, 0);
266 bool result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
267 // no location permission
268 EXPECT_EQ(false, result);
269 backgroundProxy_->OnDeleteRequestRecord(request_);
270 result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
271 EXPECT_EQ(false, result);
272 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnPermissionChanged001 end");
273 }
274
275 /*
276 * @tc.name: OnSaStateChange001
277 * @tc.desc: Test the function OnSaStateChange
278 * @tc.type: FUNC
279 */
280 HWTEST_F(LocatorServiceTest, OnSaStateChange001, TestSize.Level1)
281 {
282 /*
283 * @tc.steps: step1. Call the onsuspend function, the process enter frozen state
284 * @tc.steps: step2. Call OnSaStateChange, disable locator ability
285 * @tc.expected: step2. return true, do not change proxy list
286 * @tc.steps: step3. Call OnSaStateChange, enable locator ability
287 * @tc.expected: step3. return true, do not change proxy list
288 */
289 GTEST_LOG_(INFO)
290 << "LocatorServiceTest, OnSaStateChange001, TestSize.Level1";
291 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnSaStateChange001 begin");
292 backgroundProxy_->OnSuspend(request_, 0);
293 bool result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
294 // no location permission
295 EXPECT_EQ(false, result);
296 backgroundProxy_->OnSaStateChange(false);
297 result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
298 // no location permission
299 EXPECT_EQ(false, result);
300 backgroundProxy_->OnSaStateChange(true);
301 result = backgroundProxy_->IsCallbackInProxy(callbackStub_);
302 // no location permission
303 EXPECT_EQ(false, result);
304 backgroundProxy_->OnDeleteRequestRecord(request_);
305 LBSLOGI(LOCATOR, "[LocatorServiceTest] OnSaStateChange001 end");
306 }
307
308 /*
309 * @tc.name: GetAddressByCoordinate001
310 * @tc.desc: Test get address by coordinate
311 * @tc.type: FUNC
312 */
313 #ifdef FEATURE_GEOCODE_SUPPORT
314 HWTEST_F(LocatorServiceTest, GetAddressByCoordinate002, TestSize.Level1)
315 {
316 /*
317 * @tc.steps: step1. build the data.
318 */
319 GTEST_LOG_(INFO)
320 << "LocatorServiceTest, GetAddressByCoordinate002, TestSize.Level1";
321 LBSLOGI(LOCATOR, "[LocatorServiceTest] GetAddressByCoordinate002 begin");
322 auto locatorAbility = LocatorAbility::GetInstance();
323 sptr<GeoConvertCallbackHost> callback = new (std::nothrow) GeoConvertCallbackHost();
324 MessageParcel data;
325 data.WriteDouble(10.5); // latitude
326 data.WriteDouble(30.2); // longitude
327 data.WriteInt32(10); // maxItems
328 data.WriteInt32(1); // locale object size = 1
329 data.WriteString16(Str8ToStr16("ZH")); // locale.getLanguage()
330 data.WriteString16(Str8ToStr16("cn")); // locale.getCountry()
331 data.WriteString16(Str8ToStr16("")); // locale.getVariant()
332 data.WriteString16(Str8ToStr16("")); // ""
333 auto request = GeocodeConvertLocationRequest::UnmarshallingMessageParcel(data);
334 locatorAbility->GetAddressByCoordinate(callback, *request);
335 LBSLOGI(LOCATOR, "[LocatorServiceTest] GetAddressByCoordinate002 end");
336 }
337 #endif
338
339 /*
340 * @tc.name: CheckPermission001
341 * @tc.desc: Test the function CheckPermission
342 * @tc.type: FUNC
343 * @tc.require: issueI5OSHX
344 */
345 HWTEST_F(LocatorServiceTest, CheckPermission001, TestSize.Level1)
346 {
347 /*
348 * @tc.steps: step1. get callingTokenId and callingFirstTokenid.
349 * @tc.steps: step2. Call GetPermissionLevel and get permission level.
350 * @tc.expected: step1. get permission level is PERMISSION_ACCURATE.
351 */
352 GTEST_LOG_(INFO)
353 << "LocatorServiceTest, CheckPermission001, TestSize.Level1";
354 LBSLOGI(LOCATOR, "[LocatorServiceTest] CheckPermission001 begin");
355 uint32_t callingTokenId = IPCSkeleton::GetCallingTokenID();
356 uint32_t callingFirstTokenid = IPCSkeleton::GetFirstTokenID();
357 PermissionManager::GetPermissionLevel(callingTokenId, callingFirstTokenid);
358 LBSLOGI(LOCATOR, "[LocatorServiceTest] CheckPermission001 end");
359 }
360
361 /*
362 * @tc.name: RegisterAppStateObserver001
363 * @tc.desc: Test the function register app state observer
364 * @tc.type: FUNC
365 * @tc.require: issueI5PX7W
366 */
367 HWTEST_F(LocatorServiceTest, RegisterAppStateObserver001, TestSize.Level1)
368 {
369 /*
370 * @tc.steps: step1. get the request manager
371 * @tc.steps: step2. register app state observer
372 * @tc.expected: return false, permission denied
373 */
374 GTEST_LOG_(INFO)
375 << "LocatorServiceTest, RegisterAppStateObserver001, TestSize.Level1";
376 LBSLOGI(LOCATOR, "[LocatorServiceTest] RegisterAppStateObserver001 begin");
377 MockNativePermission();
378 backgroundProxy_->RegisterAppStateObserver();
379 LBSLOGI(LOCATOR, "[LocatorServiceTest] RegisterAppStateObserver001 end");
380 }
381
382 /*
383 * @tc.name: UnregisterAppStateObserver001
384 * @tc.desc: Test the function unregister app state observer
385 * @tc.type: FUNC
386 * @tc.require: issueI5PX7W
387 */
388 HWTEST_F(LocatorServiceTest, UnregisterAppStateObserver001, TestSize.Level1)
389 {
390 /*
391 * @tc.steps: step1. get the request manager
392 * @tc.steps: step2. unregister app state observer
393 * @tc.expected: return true, unreg process is success
394 */
395 GTEST_LOG_(INFO)
396 << "LocatorServiceTest, UnregisterAppStateObserver001, TestSize.Level1";
397 LBSLOGI(LOCATOR, "[LocatorServiceTest] UnregisterAppStateObserver001 begin");
398 bool ret = backgroundProxy_->UnregisterAppStateObserver();
399 EXPECT_EQ(true, ret);
400 LBSLOGI(LOCATOR, "[LocatorServiceTest] UnregisterAppStateObserver001 end");
401 }
402
403 /*
404 * @tc.name: UpdateListOnRequestChange001
405 * @tc.desc: Test update list on request change in normal scenario
406 * @tc.type: FUNC
407 * @tc.require: issueI5PX7W
408 */
409 HWTEST_F(LocatorServiceTest, UpdateListOnRequestChange001, TestSize.Level1)
410 {
411 /*
412 * @tc.steps: step1. get user id
413 * @tc.steps: step2. get uid by bundle name and userId
414 */
415 GTEST_LOG_(INFO)
416 << "LocatorServiceTest, UpdateListOnRequestChange001, TestSize.Level1";
417 LBSLOGI(LOCATOR, "[LocatorServiceTest] UpdateListOnRequestChange001 begin");
418 int32_t userId = 0;
419 CommonUtils::GetCurrentUserId(userId);
420
421 sptr<ISystemAbilityManager> smgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
422 EXPECT_NE(nullptr, smgr);
423 sptr<IRemoteObject> remoteObject = smgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
424 EXPECT_NE(nullptr, remoteObject);
425 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy(new AppExecFwk::BundleMgrProxy(remoteObject));
426 EXPECT_NE(nullptr, bundleMgrProxy);
427 std::string name = "ohos.global.systemres";
428 int32_t uid = bundleMgrProxy->GetUidByBundleName(name, userId);
429
430 LBSLOGD(LOCATOR, "bundleName : %{public}s, uid = %{public}d", name.c_str(), uid);
431
432 request_->SetUid(uid);
433 request_->SetPackageName(name);
434
435 /*
436 * @tc.steps: step3. test update list on request change function
437 * @tc.expected: normal scenario covered
438 */
439 backgroundProxy_->UpdateListOnRequestChange(request_);
440 LBSLOGI(LOCATOR, "[LocatorServiceTest] UpdateListOnRequestChange001 end");
441 }
442
443 /*
444 * @tc.name: UpdateListOnRequestChange002
445 * @tc.desc: Test update list on request change in abnormal scenario
446 * @tc.type: FUNC
447 * @tc.require: issueI5PX7W
448 */
449 HWTEST_F(LocatorServiceTest, UpdateListOnRequestChange002, TestSize.Level1)
450 {
451 /*
452 * @tc.steps: step1. cannot find bundle name if uid is not restored
453 * @tc.expected: early return because bundleName can not be found
454 */
455 GTEST_LOG_(INFO)
456 << "LocatorServiceTest, UpdateListOnRequestChange002, TestSize.Level1";
457 LBSLOGI(LOCATOR, "[LocatorServiceTest] UpdateListOnRequestChange002 begin");
458 ASSERT_TRUE(backgroundProxy_ != nullptr);
459 backgroundProxy_->UpdateListOnRequestChange(request_);
460
461 /*
462 * @tc.steps: step2. request is null
463 * @tc.expected: early return because request is nullptr
464 */
465 backgroundProxy_->UpdateListOnRequestChange(nullptr);
466 LBSLOGI(LOCATOR, "[LocatorServiceTest] UpdateListOnRequestChange002 end");
467 }
468
469 HWTEST_F(LocatorServiceTest, locatorServiceEnableAndDisable001, TestSize.Level1)
470 {
471 GTEST_LOG_(INFO)
472 << "LocatorServiceTest, locatorServiceEnableAndDisable001, TestSize.Level1";
473 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceEnableAndDisable001 begin");
474 auto locatorAbility = LocatorAbility::GetInstance();
475 int state = DISABLED;
476 locatorAbility->EnableAbility(true);
477
478 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->GetSwitchState(state));
479 locatorAbility->EnableAbility(false);
480 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->GetSwitchState(state));
481 locatorAbility->EnableAbility(true);
482 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->GetSwitchState(state));
483
484 locatorAbility->GetSwitchState(state);
485
486 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceEnableAndDisable001 end");
487 }
488
489 HWTEST_F(LocatorServiceTest, GetSwitchState001, TestSize.Level1)
490 {
491 GTEST_LOG_(INFO)
492 << "LocatorServiceTest, GetSwitchState001, TestSize.Level1";
493 LBSLOGI(LOCATOR, "[LocatorServiceTest] GetSwitchState001 begin");
494 auto locatorAbility = LocatorAbility::GetInstance();
495 int state = DISABLED;
496 LocationDataRdbManager::SetSwitchStateToSysparaForCurrentUser(ENABLED_SWITCHMODE);
497 locatorAbility->GetSwitchState(state);
498 LocationDataRdbManager::SetSwitchStateToSysparaForCurrentUser(DISABLED_SWITCHMODE);
499 locatorAbility->GetSwitchState(state);
500 LocationDataRdbManager::SetSwitchStateToSysparaForCurrentUser(DEFAULT_SWITCHMODE);
501 locatorAbility->GetSwitchState(state);
502 LBSLOGI(LOCATOR, "[LocatorServiceTest] GetSwitchState001 end");
503 }
504
505 HWTEST_F(LocatorServiceTest, locatorServiceEnableAndDisable002, TestSize.Level1)
506 {
507 GTEST_LOG_(INFO)
508 << "LocatorServiceTest, locatorServiceEnableAndDisable002, TestSize.Level1";
509 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceEnableAndDisable002 begin");
510 auto locatorAbility = LocatorAbility::GetInstance();
511 int currentSwitchState = LocationDataRdbManager::QuerySwitchState();
512 bool isEnable = currentSwitchState == 0 ? true: false;
513 LocationDataRdbManager::SetSwitchStateToDb(0);
514 locatorAbility->EnableAbility(isEnable);
515 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceEnableAndDisable002 end");
516 }
517
518 #ifdef FEATURE_GNSS_SUPPORT
519 HWTEST_F(LocatorServiceTest, locatorServiceCallbackRegAndUnreg001, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO)
522 << "LocatorServiceTest, locatorServiceCallbackRegAndUnreg001, TestSize.Level1";
523 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceCallbackRegAndUnreg001 begin");
524 auto locatorAbility = LocatorAbility::GetInstance();
525 auto cachedLocationsCallbackHost =
526 sptr<CachedLocationsCallbackNapi>(new (std::nothrow) CachedLocationsCallbackNapi());
527 auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
528 auto cachedRequest = std::make_unique<CachedGnssLocationsRequest>();
529 int32_t reportingPeriodSec = 1;
530 bool wakeUpCacheQueueFull = true;
531 // uid pid not match locationhub process
532 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorAbility->RegisterCachedLocationCallback(
533 reportingPeriodSec, wakeUpCacheQueueFull, cachedCallback, "unit.test"));
534 sleep(1);
535 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED,
536 locatorAbility->UnregisterCachedLocationCallback(cachedCallback)); // uid pid not match locationhub process
537 sleep(1);
538 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceCallbackRegAndUnreg001 end");
539 }
540 #endif
541
542 HWTEST_F(LocatorServiceTest, locatorServicePrivacyConfirmStatus001, TestSize.Level1)
543 {
544 GTEST_LOG_(INFO)
545 << "LocatorServiceTest, locatorServicePrivacyConfirmStatus001, TestSize.Level1";
546 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePrivacyConfirmStatus001 begin");
547 auto locatorAbility = LocatorAbility::GetInstance();
548 locatorAbility->SetLocationPrivacyConfirmStatus(PRIVACY_TYPE_STARTUP, true);
549 bool isConfirmed = false;
550 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->IsLocationPrivacyConfirmed(PRIVACY_TYPE_STARTUP, isConfirmed));
551 EXPECT_EQ(true, isConfirmed);
552 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePrivacyConfirmStatus001 end");
553 }
554
555 #ifdef FEATURE_GNSS_SUPPORT
556 HWTEST_F(LocatorServiceTest, locatorServiceSendCommand001, TestSize.Level1)
557 {
558 GTEST_LOG_(INFO)
559 << "LocatorServiceTest, locatorServiceSendCommand001, TestSize.Level1";
560 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendCommand001 begin");
561 auto locatorAbility = LocatorAbility::GetInstance();
562 // uid pid not match locationhub process
563 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->SendCommand(SCENE_NAVIGATION, "cmd"));
564 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendCommand001 end");
565 }
566 #endif
567
568 HWTEST_F(LocatorServiceTest, locatorServiceLocationMock001, TestSize.Level1)
569 {
570 GTEST_LOG_(INFO)
571 << "LocatorServiceTest, locatorServiceLocationMock001, TestSize.Level1";
572 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceLocationMock001 begin");
573 auto locatorAbility = LocatorAbility::GetInstance();
574 int timeInterval = 2;
575 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->EnableLocationMock());
576 std::vector<Location> locations;
577 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->SetMockedLocations(timeInterval, locations));
578
579 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->DisableLocationMock());
580 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->SetMockedLocations(timeInterval, locations));
581 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceLocationMock001 end");
582 }
583
584 HWTEST_F(LocatorServiceTest, locatorServiceReportLocationStatus001, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO)
587 << "LocatorServiceTest, locatorServiceReportLocationStatus001, TestSize.Level1";
588 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocationStatus001 begin");
589 auto locatorAbility = LocatorAbility::GetInstance();
590 int state = DISABLED;
591 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->GetSwitchState(state));
592 if (state == ENABLED) {
593 EXPECT_EQ(REPLY_CODE_NO_EXCEPTION, locatorAbility->ReportLocationStatus(callbackStub_, 0));
594 }
595 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocationStatus001 end");
596 }
597
598 HWTEST_F(LocatorServiceTest, locatorServiceReportErrorStatus001, TestSize.Level1)
599 {
600 GTEST_LOG_(INFO)
601 << "LocatorServiceTest, locatorServiceReportErrorStatus001, TestSize.Level1";
602 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportErrorStatus001 begin");
603 auto locatorAbility = LocatorAbility::GetInstance();
604 int state = DISABLED;
605 EXPECT_EQ(ERRCODE_SUCCESS, locatorAbility->GetSwitchState(state));
606 if (state == ENABLED) {
607 EXPECT_EQ(REPLY_CODE_NO_EXCEPTION, locatorAbility->ReportErrorStatus(callbackStub_, 0));
608 }
609 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportErrorStatus001 end");
610 }
611
612 HWTEST_F(LocatorServiceTest, locatorServiceGetReceivers001, TestSize.Level1)
613 {
614 GTEST_LOG_(INFO)
615 << "LocatorServiceTest, locatorServiceGetReceivers001, TestSize.Level1";
616 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceGetReceivers001 begin");
617 auto locatorAbility = LocatorAbility::GetInstance();
618 EXPECT_EQ(0, locatorAbility->GetReceivers()->size());
619 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceGetReceivers001 end");
620 }
621
622 HWTEST_F(LocatorServiceTest, locatorServiceProxyForFreeze001, TestSize.Level1)
623 {
624 GTEST_LOG_(INFO)
625 << "LocatorServiceTest, locatorServiceProxyForFreeze001, TestSize.Level1";
626 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceProxyForFreeze001 begin");
627 auto locatorAbility = LocatorAbility::GetInstance();
628 std::vector<int32_t> pidList;
629 pidList.push_back(SYSTEM_UID);
630 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ProxyForFreeze(pidList, true));
631 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ProxyForFreeze(pidList, false));
632 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ProxyForFreeze(pidList, true));
633 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ResetAllProxy());
634 EXPECT_EQ(false, ProxyFreezeManager::GetInstance()->IsProxyPid(SYSTEM_UID));
635 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceProxyForFreeze001 end");
636 }
637
638 HWTEST_F(LocatorServiceTest, LocatorAbilityStubDump001, TestSize.Level1)
639 {
640 GTEST_LOG_(INFO)
641 << "LocatorServiceTest, LocatorAbilityStubDump001, TestSize.Level1";
642 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityStubDump001 begin");
643 auto locatorAbility = LocatorAbility::GetInstance();
644 int32_t fd = 0;
645 std::vector<std::u16string> args;
646 std::u16string arg1 = Str8ToStr16("arg1");
647 args.emplace_back(arg1);
648 std::u16string arg2 = Str8ToStr16("arg2");
649 args.emplace_back(arg2);
650 std::u16string arg3 = Str8ToStr16("arg3");
651 args.emplace_back(arg3);
652 std::u16string arg4 = Str8ToStr16("arg4");
653 args.emplace_back(arg4);
654 EXPECT_EQ(ERR_OK, locatorAbility->Dump(fd, args));
655
656 std::vector<std::u16string> emptyArgs;
657 EXPECT_EQ(ERR_OK, locatorAbility->Dump(fd, emptyArgs));
658
659 std::vector<std::u16string> helpArgs;
660 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
661 helpArgs.emplace_back(helpArg1);
662 EXPECT_EQ(ERR_OK, locatorAbility->Dump(fd, helpArgs));
663 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityStubDump001 end");
664 }
665
666 HWTEST_F(LocatorServiceTest, LocatorAbilityGetProxyMap001, TestSize.Level1)
667 {
668 GTEST_LOG_(INFO)
669 << "LocatorServiceTest, LocatorAbilityGetProxyMap001, TestSize.Level1";
670 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityGetProxyMap001 begin");
671 auto locatorAbility = LocatorAbility::GetInstance();
672 ASSERT_TRUE(locatorAbility != nullptr);
673 locatorAbility->GetProxyMap();
674 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityGetProxyMap001 end");
675 }
676
677 HWTEST_F(LocatorServiceTest, LocatorAbilityGetProxyMap002, TestSize.Level1)
678 {
679 GTEST_LOG_(INFO)
680 << "LocatorServiceTest, LocatorAbilityGetProxyMap002, TestSize.Level1";
681 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityGetProxyMap002 begin");
682 auto locatorAbility = LocatorAbility::GetInstance();
683 ASSERT_TRUE(locatorAbility != nullptr);
684 locatorAbility->InitRequestManagerMap();
685 LBSLOGI(LOCATOR, "[LocatorServiceTest] LocatorAbilityGetProxyMap002 end");
686 }
687
688 HWTEST_F(LocatorServiceTest, locatorServicePreProxyForFreeze001, TestSize.Level1)
689 {
690 GTEST_LOG_(INFO)
691 << "LocatorServiceTest, locatorServicePreProxyForFreeze001, TestSize.Level1";
692 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePreProxyForFreeze001 begin");
693 auto locatorAbility = LocatorAbility::GetInstance();
694 std::vector<int32_t> pidList;
695 pidList.push_back(1);
696 bool isProxy = false;
697 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ProxyForFreeze(pidList, isProxy));
698 EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED, locatorAbility->ResetAllProxy());
699 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePreProxyForFreeze001 end");
700 }
701
702 HWTEST_F(LocatorServiceTest, locatorServiceOnAddSystemAbility001, TestSize.Level1)
703 {
704 GTEST_LOG_(INFO)
705 << "LocatorServiceTest, locatorServiceOnAddSystemAbility001, TestSize.Level1";
706 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnAddSystemAbility001 begin");
707 auto locatorAbility = LocatorAbility::GetInstance();
708 locatorAbility->locatorEventSubscriber_ = nullptr;
709 locatorAbility->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "device-id");
710 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnAddSystemAbility001 end");
711 }
712
713 HWTEST_F(LocatorServiceTest, locatorServiceOnRemoveSystemAbility001, TestSize.Level1)
714 {
715 GTEST_LOG_(INFO)
716 << "LocatorServiceTest, locatorServiceOnRemoveSystemAbility001, TestSize.Level1";
717 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnRemoveSystemAbility001 begin");
718 auto locatorAbility = LocatorAbility::GetInstance();
719 locatorAbility->locatorEventSubscriber_ = nullptr;
720 locatorAbility->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "device-id");
721
722 OHOS::EventFwk::MatchingSkills matchingSkills;
723 matchingSkills.AddEvent(MODE_CHANGED_EVENT);
724 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
725 locatorAbility->locatorEventSubscriber_ = std::make_shared<LocatorEventSubscriber>(subscriberInfo);
726 locatorAbility->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "device-id");
727 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnRemoveSystemAbility001 end");
728 }
729
730 HWTEST_F(LocatorServiceTest, locatorServiceOnRemoveSystemAbility002, TestSize.Level1)
731 {
732 GTEST_LOG_(INFO)
733 << "LocatorServiceTest, locatorServiceOnRemoveSystemAbility002, TestSize.Level1";
734 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnRemoveSystemAbility002 begin");
735 auto locatorAbility = LocatorAbility::GetInstance();
736 locatorAbility->locationPrivacyEventSubscriber_ = nullptr;
737 locatorAbility->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, "device-id");
738 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceOnRemoveSystemAbility002 end");
739 }
740
741 HWTEST_F(LocatorServiceTest, locatorServiceInit001, TestSize.Level1)
742 {
743 GTEST_LOG_(INFO)
744 << "LocatorServiceTest, locatorServiceInit001, TestSize.Level1";
745 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInit001 begin");
746 auto locatorAbility = LocatorAbility::GetInstance();
747 locatorAbility->registerToAbility_ = true;
748 locatorAbility->Init();
749 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInit001 end");
750 }
751
752 HWTEST_F(LocatorServiceTest, locatorServiceInitRequestManagerMap001, TestSize.Level1)
753 {
754 GTEST_LOG_(INFO)
755 << "LocatorServiceTest, locatorServiceInitRequestManagerMap001, TestSize.Level1";
756 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitRequestManagerMap001 begin");
757 auto locatorAbility = LocatorAbility::GetInstance();
758 locatorAbility->requests_ = nullptr;
759 locatorAbility->InitRequestManagerMap();
760 locatorAbility->requests_ = std::make_shared<std::map<std::string, std::list<std::shared_ptr<Request>>>>();
761 locatorAbility->GetActiveRequestNum();
762 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitRequestManagerMap001 end");
763 }
764
765 HWTEST_F(LocatorServiceTest, locatorServiceInitSaAbility002, TestSize.Level1)
766 {
767 GTEST_LOG_(INFO)
768 << "LocatorServiceTest, locatorServiceInitSaAbility002, TestSize.Level1";
769 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitSaAbility002 begin");
770 auto locatorAbility = LocatorAbility::GetInstance();
771 locatorAbility->proxyMap_ = nullptr;
772 locatorAbility->InitSaAbility();
773
774 locatorAbility->proxyMap_ = std::make_shared<std::map<std::string, sptr<IRemoteObject>>>();
775 locatorAbility->InitSaAbility();
776 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitSaAbility002 end");
777 }
778
779 HWTEST_F(LocatorServiceTest, locatorServiceSendLocationMockMsgToGnssSa001, TestSize.Level1)
780 {
781 GTEST_LOG_(INFO)
782 << "LocatorServiceTest, locatorServiceSendLocationMockMsgToGnssSa001, TestSize.Level1";
783 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendLocationMockMsgToGnssSa001 begin");
784 auto locatorAbility = LocatorAbility::GetInstance();
785 std::vector<std::shared_ptr<OHOS::Location::Location>> locations;
786 #ifdef FEATURE_GNSS_SUPPORT
787 locatorAbility->SendLocationMockMsgToGnssSa(nullptr, 0, locations, 0);
788 #endif
789 locatorAbility->SendLocationMockMsgToNetworkSa(nullptr, 0, locations, 0);
790 locatorAbility->SendLocationMockMsgToPassiveSa(nullptr, 0, locations, 0);
791 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendLocationMockMsgToGnssSa001 end");
792 }
793
794 HWTEST_F(LocatorServiceTest, locatorServiceStartLocating001, TestSize.Level1)
795 {
796 GTEST_LOG_(INFO)
797 << "LocatorServiceTest, locatorServiceStartLocating001, TestSize.Level1";
798 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceStartLocating001 begin");
799 auto locatorAbility = LocatorAbility::GetInstance();
800
801 locatorAbility->proxyMap_ = std::make_shared<std::map<std::string, sptr<IRemoteObject>>>();
802 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
803 requestConfig->SetFixNumber(1);
804 requestConfig->SetPriority(LOCATION_PRIORITY_LOCATING_SPEED);
805 sptr<ILocatorCallback> callbackStub = new (std::nothrow) LocatorCallbackStub();
806 MessageParcel parcel;
807 parcel.WriteDouble(12.0); // latitude
808 parcel.WriteDouble(13.0); // longitude
809 parcel.WriteDouble(14.0); // altitude
810 parcel.WriteDouble(1000.0); // accuracy
811 parcel.WriteDouble(10.0); // speed
812 parcel.WriteDouble(90.0); // direction
813 parcel.WriteInt64(1000000000); // timeStamp
814 parcel.WriteInt64(1000000000); // timeSinceBoot
815 parcel.WriteString16(u"additions"); // additions
816 parcel.WriteInt64(1); // additionSize
817 parcel.WriteInt32(1); // isFromMock
818 std::unique_ptr<Location> location = std::make_unique<Location>();
819 location->ReadFromParcel(parcel);
820 location->SetLocationSourceType(1);
821 locatorAbility->reportManager_->UpdateCacheLocation(location, NETWORK_ABILITY);
822
823 LocationDataRdbManager::SetSwitchStateToDb(ENABLED);
824 locatorAbility->StartLocating(*requestConfig, callbackStub);
825 LocationDataRdbManager::SetSwitchStateToDb(DISABLED);
826 locatorAbility->StartLocating(*requestConfig, callbackStub);
827
828 sptr<IRemoteObject> objectGnss = CommonUtils::GetRemoteObject(LOCATION_GNSS_SA_ID, CommonUtils::InitDeviceId());
829 locatorAbility->proxyMap_->insert(make_pair(GNSS_ABILITY, objectGnss));
830 locatorAbility->reportManager_ = nullptr;
831 locatorAbility->StartLocating(*requestConfig, callbackStub);
832 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceStartLocating001 end");
833 }
834
835 HWTEST_F(LocatorServiceTest, locatorServiceGetCacheLocation001, TestSize.Level1)
836 {
837 GTEST_LOG_(INFO)
838 << "LocatorServiceTest, locatorServiceGetCacheLocation001, TestSize.Level1";
839 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceGetCacheLocation001 begin");
840 auto locatorAbility = LocatorAbility::GetInstance();
841 AppIdentity identity;
842 MessageParcel parcel;
843 parcel.WriteDouble(0.0); // latitude
844 parcel.WriteDouble(0.0); // longitude
845 parcel.WriteDouble(14.0); // altitude
846 parcel.WriteDouble(1000.0); // accuracy
847 parcel.WriteDouble(10.0); // speed
848 parcel.WriteDouble(90.0); // direction
849 parcel.WriteInt64(1000000000); // timeStamp
850 parcel.WriteInt64(1000000000); // timeSinceBoot
851 parcel.WriteString16(u"additions"); // additions
852 parcel.WriteInt64(1); // additionSize
853 parcel.WriteInt32(1); // isFromMock
854 std::unique_ptr<Location> location = std::make_unique<Location>();
855 location->ReadFromParcel(parcel);
856 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceGetCacheLocation001 end");
857 }
858
859 HWTEST_F(LocatorServiceTest, locatorServiceReportLocation001, TestSize.Level1)
860 {
861 GTEST_LOG_(INFO)
862 << "LocatorServiceTest, locatorServiceReportLocation001, TestSize.Level1";
863 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocation001 begin");
864 auto locatorAbility = LocatorAbility::GetInstance();
865 locatorAbility->requests_ = nullptr;
866 std::unique_ptr<Location> location = std::make_unique<Location>();
867 EXPECT_EQ(ERRCODE_SERVICE_UNAVAILABLE, locatorAbility->ReportLocation("test", *location));
868 locatorAbility->requests_ = std::make_shared<std::map<std::string, std::list<std::shared_ptr<Request>>>>();
869 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocation001 end");
870 }
871
872 HWTEST_F(LocatorServiceTest, locatorServiceRegisterPermissionCallback001, TestSize.Level1)
873 {
874 GTEST_LOG_(INFO)
875 << "LocatorServiceTest, locatorServiceReportLocation001, TestSize.Level1";
876 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocation001 begin");
877 auto locatorAbility = LocatorAbility::GetInstance();
878 locatorAbility->permissionMap_ = nullptr;
879 std::vector<std::string> permissionNameList;
880 locatorAbility->RegisterPermissionCallback(0, permissionNameList);
881 locatorAbility->UnregisterPermissionCallback(0);
882 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceReportLocation001 end");
883 }
884
885 HWTEST_F(LocatorServiceTest, locatorServiceRemoveUnloadTask001, TestSize.Level1)
886 {
887 GTEST_LOG_(INFO)
888 << "LocatorServiceTest, locatorServiceRemoveUnloadTask001, TestSize.Level1";
889 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceRemoveUnloadTask001 begin");
890 auto locatorAbility = LocatorAbility::GetInstance();
891 locatorAbility->RemoveUnloadTask(DEFAULT_CODE);
892 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceRemoveUnloadTask001 end");
893 }
894
895 HWTEST_F(LocatorServiceTest, locatorServiceRemoveUnloadTask002, TestSize.Level1)
896 {
897 GTEST_LOG_(INFO)
898 << "LocatorServiceTest, locatorServiceRemoveUnloadTask002, TestSize.Level1";
899 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceRemoveUnloadTask002 begin");
900 auto locatorAbility = LocatorAbility::GetInstance();
901 locatorAbility->RemoveUnloadTask(GET_SWITCH_STATE);
902 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceRemoveUnloadTask002 end");
903 }
904
905 HWTEST_F(LocatorServiceTest, locatorServicePostUnloadTask001, TestSize.Level1)
906 {
907 GTEST_LOG_(INFO)
908 << "LocatorServiceTest, locatorServicePostUnloadTask001, TestSize.Level1";
909 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePostUnloadTask001 begin");
910 auto locatorAbility = LocatorAbility::GetInstance();
911 locatorAbility->PostUnloadTask(static_cast<uint16_t>(LocatorInterfaceCode::PROXY_PID_FOR_FREEZE));
912 locatorAbility->PostUnloadTask(static_cast<uint16_t>(LocatorInterfaceCode::RESET_ALL_PROXY));
913 locatorAbility->PostUnloadTask(DEFAULT_CODE);
914 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePostUnloadTask001 end");
915 }
916
917 HWTEST_F(LocatorServiceTest, locatorServicePostUnloadTask002, TestSize.Level1)
918 {
919 GTEST_LOG_(INFO)
920 << "LocatorServiceTest, locatorServicePostUnloadTask002, TestSize.Level1";
921 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePostUnloadTask002 begin");
922 auto locatorAbility = LocatorAbility::GetInstance();
923 locatorAbility->PostUnloadTask(GET_SWITCH_STATE);
924 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServicePostUnloadTask002 end");
925 }
926
927 HWTEST_F(LocatorServiceTest, locatorServiceSendSwitchState001, TestSize.Level1)
928 {
929 GTEST_LOG_(INFO)
930 << "LocatorServiceTest, locatorServiceSendSwitchState001, TestSize.Level1";
931 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendSwitchState001 begin");
932 auto locatorAbility = LocatorAbility::GetInstance();
933 locatorAbility->SendSwitchState(0);
934 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceSendSwitchState001 end");
935 }
936
937 HWTEST_F(LocatorServiceTest, locatorServiceInitRequest001, TestSize.Level1)
938 {
939 GTEST_LOG_(INFO)
940 << "LocatorServiceTest, locatorServiceInitRequest001, TestSize.Level1";
941 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitRequest001 begin");
942 auto locatorAbility = LocatorAbility::GetInstance();
943 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
944 AppIdentity identity;
945 std::shared_ptr<Request> request = std::make_shared<Request>(requestConfig, callbackStub_, identity);
946 EXPECT_NE(nullptr, request);
947 LBSLOGI(LOCATOR, "[LocatorServiceTest] locatorServiceInitRequest001 end");
948 }
949
950 HWTEST_F(LocatorServiceTest, IsCacheVaildScenario001, TestSize.Level1)
951 {
952 GTEST_LOG_(INFO)
953 << "LocatorServiceTest, IsCacheVaildScenario001, TestSize.Level1";
954 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsCacheVaildScenario001 begin");
955 auto locatorAbility = LocatorAbility::GetInstance();
956 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
957 AppIdentity identity;
958 std::shared_ptr<Request> request = std::make_shared<Request>(requestConfig, callbackStub_, identity);
959 locatorAbility->IsCacheVaildScenario(request->GetRequestConfig());
960 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsCacheVaildScenario001 end");
961 }
962
963 HWTEST_F(LocatorServiceTest, IsSingleRequest001, TestSize.Level1)
964 {
965 GTEST_LOG_(INFO)
966 << "LocatorServiceTest, IsSingleRequest001, TestSize.Level1";
967 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsSingleRequest001 begin");
968 auto locatorAbility = LocatorAbility::GetInstance();
969 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
970 AppIdentity identity;
971 std::shared_ptr<Request> request = std::make_shared<Request>(requestConfig, callbackStub_, identity);
972 bool res = locatorAbility->IsSingleRequest(request->GetRequestConfig());
973 EXPECT_EQ(false, res);
974 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsSingleRequest001 end");
975 }
976
977 HWTEST_F(LocatorServiceTest, RemoveInvalidRequests, TestSize.Level1)
978 {
979 GTEST_LOG_(INFO)
980 << "LocatorServiceTest, RemoveInvalidRequests, TestSize.Level1";
981 LBSLOGI(LOCATOR, "[LocatorServiceTest] RemoveInvalidRequests begin");
982 auto locatorAbility = LocatorAbility::GetInstance();
983 auto ret = locatorAbility->RemoveInvalidRequests();
984 EXPECT_EQ(ERRCODE_SUCCESS, ret);
985 LBSLOGI(LOCATOR, "[LocatorServiceTest] RemoveInvalidRequests end");
986 }
987
988 HWTEST_F(LocatorServiceTest, IsInvalidRequest, TestSize.Level1)
989 {
990 GTEST_LOG_(INFO)
991 << "LocatorServiceTest, IsInvalidRequest, TestSize.Level1";
992 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsInvalidRequest begin");
993 auto locatorAbility = LocatorAbility::GetInstance();
994 std::shared_ptr<Request> request = std::make_shared<Request>();
995 locatorAbility->IsInvalidRequest(request);
996 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsInvalidRequest end");
997 }
998
999 HWTEST_F(LocatorServiceTest, IsPorcessRunning, TestSize.Level1)
1000 {
1001 GTEST_LOG_(INFO)
1002 << "LocatorServiceTest, IsPorcessRunning, TestSize.Level1";
1003 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsPorcessRunning begin");
1004 auto locatorAbility = LocatorAbility::GetInstance();
1005 auto result = locatorAbility->IsProcessRunning(1000, 1000);
1006 EXPECT_EQ(false, result);
1007 LBSLOGI(LOCATOR, "[LocatorServiceTest] IsPorcessRunning end");
1008 }
1009 } // namespace Location
1010 } // namespace OHOS
1011