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_impl_test.h"
17
18 #include "accesstoken_kit.h"
19 #include "message_parcel.h"
20 #include "nativetoken_kit.h"
21 #include "system_ability_definition.h"
22 #include "token_setproc.h"
23 #include "iremote_object.h"
24
25 #ifdef FEATURE_GNSS_SUPPORT
26 #include "cached_locations_callback_napi.h"
27 #endif
28 #include "common_utils.h"
29 #include "constant_definition.h"
30 #include "country_code.h"
31 #include "country_code_callback_napi.h"
32 #ifdef FEATURE_GEOCODE_SUPPORT
33 #include "geo_address.h"
34 #endif
35 #ifdef FEATURE_GNSS_SUPPORT
36 #include "gnss_status_callback_napi.h"
37 #include "i_cached_locations_callback.h"
38 #endif
39 #include "location.h"
40 #include "location_sa_load_manager.h"
41 #include "location_switch_callback_napi.h"
42 #include "locator.h"
43 #include "locator_callback_proxy.h"
44 #include "locator_proxy.h"
45 #ifdef FEATURE_GNSS_SUPPORT
46 #include "nmea_message_callback_napi.h"
47 #endif
48 #include "request_config.h"
49 #include "locating_required_data_callback_napi.h"
50 #include "bluetooth_scan_result_callback_napi.h"
51 #include "locator_agent.h"
52 #include "permission_manager.h"
53 #include "geofence_request.h"
54 #include "geofence_sdk.h"
55 #include "location_data_rdb_manager.h"
56
57 using namespace testing::ext;
58
59 namespace OHOS {
60 namespace Location {
61 const int32_t LOCATION_PERM_NUM = 6;
62 const int INVALID_PRIVACY_TYPE = -1;
63 const int32_t DEFAULT_USER = 100;
64 #ifdef FEATURE_GNSS_SUPPORT
65 const int INVALID_CACHED_SIZE = 0;
66 #endif
67 #ifdef FEATURE_GEOCODE_SUPPORT
68 const double MOCK_LATITUDE = 99.0;
69 const double MOCK_LONGITUDE = 100.0;
70 #endif
SetUp()71 void LocatorImplTest::SetUp()
72 {
73 MockNativePermission();
74 LoadSystemAbility();
75 locatorImpl_ = Locator::GetInstance();
76 ASSERT_TRUE(locatorImpl_ != nullptr);
77 callbackStub_ = new (std::nothrow) LocatorCallbackStub();
78 ASSERT_TRUE(callbackStub_ != nullptr);
79 }
80
TearDown()81 void LocatorImplTest::TearDown()
82 {
83 }
84
LoadSystemAbility()85 void LocatorImplTest::LoadSystemAbility()
86 {
87 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_LOCATOR_SA_ID);
88 #ifdef FEATURE_GNSS_SUPPORT
89 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_GNSS_SA_ID);
90 #endif
91 #ifdef FEATURE_PASSIVE_SUPPORT
92 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_NOPOWER_LOCATING_SA_ID);
93 #endif
94 #ifdef FEATURE_NETWORK_SUPPORT
95 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_NETWORK_LOCATING_SA_ID);
96 #endif
97 #ifdef FEATURE_GEOCODE_SUPPORT
98 LocationSaLoadManager::GetInstance()->LoadLocationSa(LOCATION_GEO_CONVERT_SA_ID);
99 #endif
100 }
101
MockNativePermission()102 void LocatorImplTest::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(), ACCESS_LOCATION_SWITCH_IGNORED.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 = "LocatorImplTest",
117 .aplStr = "system_basic",
118 };
119 tokenId_ = GetAccessTokenId(&infoInstance);
120 SetSelfTokenID(tokenId_);
121 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
122 }
123
124 #ifdef FEATURE_GEOCODE_SUPPORT
SetGeocodingMockInfo()125 std::vector<std::shared_ptr<GeocodingMockInfo>> LocatorImplTest::SetGeocodingMockInfo()
126 {
127 std::vector<std::shared_ptr<GeocodingMockInfo>> geoMockInfos;
128 std::shared_ptr<GeocodingMockInfo> geocodingMockInfo =
129 std::make_shared<GeocodingMockInfo>();
130 MessageParcel parcel;
131 parcel.WriteString16(Str8ToStr16("locale"));
132 parcel.WriteDouble(MOCK_LATITUDE); // latitude
133 parcel.WriteDouble(MOCK_LONGITUDE); // longitude
134 parcel.WriteInt32(1);
135 parcel.WriteString("localeLanguage");
136 parcel.WriteString("localeCountry");
137 parcel.WriteInt32(1); // size
138 parcel.WriteInt32(0); // line
139 parcel.WriteString("line");
140 parcel.WriteString("placeName");
141 parcel.WriteString("administrativeArea");
142 parcel.WriteString("subAdministrativeArea");
143 parcel.WriteString("locality");
144 parcel.WriteString("subLocality");
145 parcel.WriteString("roadName");
146 parcel.WriteString("subRoadName");
147 parcel.WriteString("premises");
148 parcel.WriteString("postalCode");
149 parcel.WriteString("countryCode");
150 parcel.WriteString("countryName");
151 parcel.WriteInt32(1); // hasLatitude
152 parcel.WriteDouble(MOCK_LATITUDE); // latitude
153 parcel.WriteInt32(1); // hasLongitude
154 parcel.WriteDouble(MOCK_LONGITUDE); // longitude
155 parcel.WriteString("phoneNumber");
156 parcel.WriteString("addressUrl");
157 parcel.WriteBool(true);
158 geocodingMockInfo->ReadFromParcel(parcel);
159 geoMockInfos.emplace_back(std::move(geocodingMockInfo));
160 return geoMockInfos;
161 }
162 #endif
163
164 HWTEST_F(LocatorImplTest, locatorImplEnableAbilityV9001, TestSize.Level1)
165 {
166 GTEST_LOG_(INFO)
167 << "LocatorImplTest, locatorImplEnableAbilityV9001, TestSize.Level1";
168 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9001 begin");
169 auto switchCallbackHost =
170 sptr<LocationSwitchCallbackNapi>(new (std::nothrow) LocationSwitchCallbackNapi());
171 EXPECT_NE(nullptr, switchCallbackHost);
172 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->RegisterSwitchCallbackV9(switchCallbackHost->AsObject()));
173 sleep(1);
174
175 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityV9(false));
176 bool isEnabled = false;
177 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->IsLocationEnabledV9(isEnabled));
178 EXPECT_EQ(false, isEnabled);
179
180 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->UnregisterSwitchCallbackV9(switchCallbackHost->AsObject()));
181 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9001 end");
182 }
183
184 HWTEST_F(LocatorImplTest, locatorImplEnableAbilityV9002, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO)
187 << "LocatorImplTest, locatorImplEnableAbilityV9002, TestSize.Level1";
188 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9002 begin");
189 auto switchCallbackHost =
190 sptr<LocationSwitchCallbackNapi>(new (std::nothrow) LocationSwitchCallbackNapi());
191 EXPECT_NE(nullptr, switchCallbackHost);
192 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->RegisterSwitchCallbackV9(switchCallbackHost->AsObject()));
193 sleep(1);
194
195 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityV9(true));
196 bool isEnabled = false;
197 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->IsLocationEnabledV9(isEnabled));
198
199 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->UnregisterSwitchCallbackV9(switchCallbackHost->AsObject()));
200 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9002 end");
201 }
202
203 HWTEST_F(LocatorImplTest, locatorImplEnableAbilityV9003, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO)
206 << "LocatorImplTest, locatorImplEnableAbilityV9002, TestSize.Level1";
207 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9002 begin");
208 sptr<IRemoteObject> callback;
209 locatorImpl_->RegisterSwitchCallbackV9(callback);
210 sleep(1);
211 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityV9(true));
212 bool isEnabled = false;
213 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->IsLocationEnabledV9(isEnabled));
214 locatorImpl_->UnregisterSwitchCallbackV9(callback);
215 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityV9002 end");
216 }
217
218 HWTEST_F(LocatorImplTest, locatorImplGetCachedLocationV9, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO)
221 << "LocatorImplTest, locatorImplGetCachedLocationV9, TestSize.Level1";
222 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetCachedLocationV9 begin");
223
224 locatorImpl_->EnableLocationMockV9(); // mock switch on
225
226 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
227 requestConfig->SetPriority(PRIORITY_ACCURACY);
228 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StartLocatingV9(requestConfig, callbackStub_)); // startLocating first
229 sleep(1);
230
231 int timeInterval = 0;
232 std::vector<std::shared_ptr<Location>> locations;
233 Parcel parcel;
234 parcel.WriteDouble(10.6); // latitude
235 parcel.WriteDouble(10.5); // longitude
236 parcel.WriteDouble(10.4); // altitude
237 parcel.WriteDouble(1.0); // accuracy
238 parcel.WriteDouble(5.0); // speed
239 parcel.WriteDouble(10); // direction
240 parcel.WriteInt64(1611000000); // timestamp
241 parcel.WriteInt64(1611000000); // time since boot
242 parcel.WriteString16(u"additions"); // additions
243 parcel.WriteInt64(1); // additionSize
244 parcel.WriteInt32(0); // isFromMock is false
245 locations.push_back(Location::UnmarshallingShared(parcel));
246 locatorImpl_->SetMockedLocationsV9(timeInterval, locations); // set fake locations
247 sleep(1);
248
249 std::unique_ptr<Location> loc = std::make_unique<Location>();
250 locatorImpl_->GetCachedLocationV9(loc); // get last location
251 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StopLocatingV9(callbackStub_));
252
253 locatorImpl_->DisableLocationMockV9();
254 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetCachedLocationV9 end");
255 }
256
257 HWTEST_F(LocatorImplTest, locatorImplDisableLocationMockV9, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO)
260 << "LocatorImplTest, locatorImplDisableLocationMockV9, TestSize.Level1";
261 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplDisableLocationMockV9 begin");
262 Locator::GetInstance()->DisableLocationMockV9();
263 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplDisableLocationMockV9 end");
264 }
265
266 HWTEST_F(LocatorImplTest, locatorImplPrivacyStateV9001, TestSize.Level1)
267 {
268 GTEST_LOG_(INFO)
269 << "LocatorImplTest, locatorImplPrivacyStateV9001, TestSize.Level1";
270 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplPrivacyStateV9001 begin");
271 bool isConfirmed = false;
272 locatorImpl_->SetLocationPrivacyConfirmStatusV9(INVALID_PRIVACY_TYPE, true);
273 locatorImpl_->IsLocationPrivacyConfirmedV9(INVALID_PRIVACY_TYPE, isConfirmed);
274 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplPrivacyStateV9001 end");
275 }
276
277 #ifdef FEATURE_GNSS_SUPPORT
278 HWTEST_F(LocatorImplTest, locatorImplGetCachedGnssLocationsSizeV9, TestSize.Level1)
279 {
280 GTEST_LOG_(INFO)
281 << "LocatorImplTest, locatorImplGetCachedGnssLocationsSizeV9, TestSize.Level1";
282 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetCachedGnssLocationsSizeV9 begin");
283 int size = INVALID_CACHED_SIZE;
284 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, locatorImpl_->GetCachedGnssLocationsSizeV9(size));
285 EXPECT_EQ(INVALID_CACHED_SIZE, size);
286 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetCachedGnssLocationsSizeV9 end");
287 }
288 #endif
289
290 #ifdef FEATURE_GNSS_SUPPORT
291 HWTEST_F(LocatorImplTest, locatorImplFlushCachedGnssLocationsV9, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO)
294 << "LocatorImplTest, locatorImplFlushCachedGnssLocationsV9, TestSize.Level1";
295 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplFlushCachedGnssLocationsV9 begin");
296 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, locatorImpl_->FlushCachedGnssLocationsV9());
297 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplFlushCachedGnssLocationsV9 end");
298 }
299 #endif
300
301 #ifdef FEATURE_GNSS_SUPPORT
302 HWTEST_F(LocatorImplTest, locatorImplSendCommandV9, TestSize.Level1)
303 {
304 GTEST_LOG_(INFO)
305 << "LocatorImplTest, locatorImplSendCommandV9, TestSize.Level1";
306 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSendCommandV9 begin");
307 std::unique_ptr<LocationCommand> command = std::make_unique<LocationCommand>();
308 command->scenario = SCENE_NAVIGATION;
309 command->command = "cmd";
310 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->SendCommandV9(command));
311 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSendCommandV9 end");
312 }
313 #endif
314
315
316 HWTEST_F(LocatorImplTest, locatorImplGetIsoCountryCodeV9, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO)
319 << "LocatorImplTest, locatorImplGetIsoCountryCodeV9, TestSize.Level1";
320 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetIsoCountryCodeV9 begin");
321
322 auto countryCodeCallbackHost =
323 sptr<CountryCodeCallbackNapi>(new (std::nothrow) CountryCodeCallbackNapi());
324 EXPECT_NE(nullptr, countryCodeCallbackHost);
325 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->RegisterCountryCodeCallbackV9(countryCodeCallbackHost->AsObject()));
326 sleep(1);
327
328 std::shared_ptr<CountryCode> countryCode = std::make_shared<CountryCode>();
329 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->GetIsoCountryCodeV9(countryCode));
330 ASSERT_TRUE(countryCode != nullptr);
331 LBSLOGI(LOCATOR, "countrycode : %{public}s", countryCode->ToString().c_str());
332 sleep(1);
333 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->UnregisterCountryCodeCallbackV9(countryCodeCallbackHost->AsObject()));
334 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetIsoCountryCodeV9 end");
335 }
336
337 HWTEST_F(LocatorImplTest, locatorImplProxyForFreeze, TestSize.Level1)
338 {
339 GTEST_LOG_(INFO)
340 << "LocatorImplTest, locatorImplProxyForFreeze, TestSize.Level1";
341 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplProxyForFreeze begin");
342 std::set<int> pidList;
343 pidList.insert(SYSTEM_UID);
344 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl_->ProxyForFreeze(pidList, false));
345 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplProxyForFreeze end");
346 }
347
348 #ifdef FEATURE_GEOCODE_SUPPORT
349 HWTEST_F(LocatorImplTest, locatorImplIsGeoServiceAvailableV9001, TestSize.Level1)
350 {
351 GTEST_LOG_(INFO)
352 << "LocatorImplTest, locatorImplIsGeoServiceAvailableV9001, TestSize.Level1";
353 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsGeoServiceAvailableV9001 begin");
354 bool isAvailable = true;
355 locatorImpl_->DisableReverseGeocodingMockV9();
356 locatorImpl_->IsGeoServiceAvailableV9(isAvailable);
357 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsGeoServiceAvailableV9001 end");
358 }
359 #endif
360
361 #ifdef FEATURE_GEOCODE_SUPPORT
362 HWTEST_F(LocatorImplTest, locatorImplGetAddressByCoordinateV9001, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO)
365 << "LocatorImplTest, locatorImplGetAddressByCoordinateV9001, TestSize.Level1";
366 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinateV9001 begin");
367 MessageParcel request001;
368 std::list<std::shared_ptr<GeoAddress>> geoAddressList001;
369 locatorImpl_->EnableReverseGeocodingMockV9();
370
371 std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfos = SetGeocodingMockInfo();
372 locatorImpl_->SetReverseGeocodingMockInfoV9(mockInfos);
373 request001.WriteInterfaceToken(LocatorProxy::GetDescriptor());
374 request001.WriteDouble(MOCK_LATITUDE); // latitude
375 request001.WriteDouble(MOCK_LONGITUDE); // longitude
376 request001.WriteInt32(3); // maxItems
377 request001.WriteInt32(1); // locale object size = 1
378 request001.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
379 request001.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
380 request001.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
381 request001.WriteString16(Str8ToStr16("")); // ""
382 locatorImpl_->GetAddressByCoordinateV9(request001, geoAddressList001);
383 EXPECT_EQ(true, geoAddressList001.empty());
384
385 locatorImpl_->DisableReverseGeocodingMockV9();
386 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinateV9001 end");
387 }
388 #endif
389
390 #ifdef FEATURE_GEOCODE_SUPPORT
391 HWTEST_F(LocatorImplTest, locatorImplGetAddressByCoordinateV9002, TestSize.Level1)
392 {
393 GTEST_LOG_(INFO)
394 << "LocatorImplTest, locatorImplGetAddressByCoordinateV9002, TestSize.Level1";
395 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinateV9002 begin");
396 MessageParcel request002;
397 std::list<std::shared_ptr<GeoAddress>> geoAddressList002;
398 locatorImpl_->DisableReverseGeocodingMockV9();
399
400 request002.WriteInterfaceToken(LocatorProxy::GetDescriptor());
401 request002.WriteDouble(1.0); // latitude
402 request002.WriteDouble(2.0); // longitude
403 request002.WriteInt32(3); // maxItems
404 request002.WriteInt32(1); // locale object size = 1
405 request002.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
406 request002.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
407 request002.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
408 request002.WriteString16(Str8ToStr16("")); // ""
409 EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, locatorImpl_->GetAddressByCoordinateV9(request002, geoAddressList002));
410 EXPECT_EQ(true, geoAddressList002.empty());
411 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinateV9002 end");
412 }
413 #endif
414
415 #ifdef FEATURE_GEOCODE_SUPPORT
416 HWTEST_F(LocatorImplTest, locatorImplGetAddressByLocationNameV9001, TestSize.Level1)
417 {
418 GTEST_LOG_(INFO)
419 << "LocatorImplTest, locatorImplGetAddressByLocationNameV9001, TestSize.Level1";
420 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByLocationNameV9001 begin");
421 MessageParcel request003;
422 std::list<std::shared_ptr<GeoAddress>> geoAddressList003;
423 request003.WriteInterfaceToken(LocatorProxy::GetDescriptor());
424 request003.WriteString16(Str8ToStr16("description")); // description
425 request003.WriteDouble(1.0); // minLatitude
426 request003.WriteDouble(2.0); // minLongitude
427 request003.WriteDouble(3.0); // maxLatitude
428 request003.WriteDouble(4.0); // maxLongitude
429 request003.WriteInt32(3); // maxItems
430 request003.WriteInt32(1); // locale object size = 1
431 request003.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
432 request003.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
433 request003.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
434 request003.WriteString16(Str8ToStr16("")); // ""
435 EXPECT_EQ(ERRCODE_GEOCODING_FAIL, locatorImpl_->GetAddressByLocationNameV9(request003, geoAddressList003));
436 EXPECT_EQ(true, geoAddressList003.empty());
437 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByLocationNameV9001 end");
438 }
439 #endif
440
441 #ifdef FEATURE_GNSS_SUPPORT
442 HWTEST_F(LocatorImplTest, locatorImplRegisterAndUnregisterCallbackV9001, TestSize.Level1)
443 {
444 GTEST_LOG_(INFO)
445 << "LocatorImplTest, locatorImplRegisterAndUnregisterCallbackV9001, TestSize.Level1";
446 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterAndUnregisterCallbackV9001 begin");
447 auto cachedLocationsCallbackHost =
448 sptr<CachedLocationsCallbackNapi>(new (std::nothrow) CachedLocationsCallbackNapi());
449 EXPECT_NE(nullptr, cachedLocationsCallbackHost);
450 auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
451 EXPECT_NE(nullptr, cachedCallback);
452 auto request = std::make_unique<CachedGnssLocationsRequest>();
453 EXPECT_NE(nullptr, request);
454 request->reportingPeriodSec = 10;
455 request->wakeUpCacheQueueFull = true;
456 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, locatorImpl_->RegisterCachedLocationCallbackV9(request, cachedCallback));
457 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, locatorImpl_->UnregisterCachedLocationCallbackV9(cachedCallback));
458 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterAndUnregisterCallbackV9001 end");
459 }
460 #endif
461
462 #ifdef FEATURE_GNSS_SUPPORT
463 HWTEST_F(LocatorImplTest, locatorImplGnssStatusCallbackV9, TestSize.Level1)
464 {
465 GTEST_LOG_(INFO)
466 << "LocatorImplTest, locatorImplGnssStatusCallbackV9, TestSize.Level1";
467 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGnssStatusCallbackV9 begin");
468 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
469 requestConfig->SetPriority(PRIORITY_ACCURACY);
470 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StartLocatingV9(requestConfig, callbackStub_)); // startLocating first
471 sleep(1);
472 auto gnssCallbackHost =
473 sptr<GnssStatusCallbackNapi>(new (std::nothrow) GnssStatusCallbackNapi());
474 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->RegisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
475 sleep(1);
476 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->UnregisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
477 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StopLocatingV9(callbackStub_)); // after reg, stop locating
478 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGnssStatusCallbackV9 end");
479 }
480 #endif
481
482 #ifdef FEATURE_GNSS_SUPPORT
483 HWTEST_F(LocatorImplTest, locatorImplNmeaMessageCallbackV9001, TestSize.Level1)
484 {
485 GTEST_LOG_(INFO)
486 << "LocatorImplTest, locatorImplNmeaMessageCallbackV9001, TestSize.Level1";
487 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplNmeaMessageCallbackV9001 begin");
488 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
489 requestConfig->SetPriority(PRIORITY_ACCURACY);
490 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StartLocatingV9(requestConfig, callbackStub_)); // startLocating first
491 sleep(1);
492 auto nmeaCallbackHost =
493 sptr<NmeaMessageCallbackNapi>(new (std::nothrow) NmeaMessageCallbackNapi());
494 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->RegisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
495 sleep(1);
496 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->UnregisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
497 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->StopLocatingV9(callbackStub_)); // after reg, stop locating
498 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplNmeaMessageCallbackV9001 end");
499 }
500 #endif
501
502 HWTEST_F(LocatorImplTest, locatorImplGetDistanceBetweenLocations001, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO)
505 << "LocatorImplTest, locatorImplGetDistanceBetweenLocations001, TestSize.Level1";
506 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetDistanceBetweenLocations001 begin");
507 ASSERT_TRUE(locatorImpl_ != nullptr);
508 Location location1;
509 location1.SetLatitude(31.123);
510 location1.SetLongitude(121.123);
511 Location location2;
512 location2.SetLatitude(31.456);
513 location2.SetLongitude(121.456);
514 double distance;
515 locatorImpl_->GetDistanceBetweenLocations(location1, location2, distance);
516 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetDistanceBetweenLocations001 end");
517 }
518
519 HWTEST_F(LocatorImplTest, locatorImplResetLocatorProxy001, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO)
522 << "LocatorImplTest, locatorImplResetLocatorProxy001, TestSize.Level1";
523 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResetLocatorProxy001 begin");
524 ASSERT_TRUE(locatorImpl_ != nullptr);
525 wptr<IRemoteObject> remote = nullptr;
526 locatorImpl_->ResetLocatorProxy(remote); // remote is nullptr
527 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResetLocatorProxy001 end");
528 }
529
530 HWTEST_F(LocatorImplTest, locatorImplOnRemoteDied001, TestSize.Level1)
531 {
532 GTEST_LOG_(INFO)
533 << "LocatorImplTest, locatorImplOnRemoteDied001, TestSize.Level1";
534 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplOnRemoteDied001 begin");
535 auto impl = Locator::GetInstance();
536 ASSERT_TRUE(impl != nullptr);
537 auto recipient =
538 sptr<LocatorImpl::LocatorDeathRecipient>(new (std::nothrow) LocatorImpl::LocatorDeathRecipient(*impl));
539 wptr<IRemoteObject> remote;
540 recipient->OnRemoteDied(remote);
541 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplOnRemoteDied001 end");
542 }
543
544 HWTEST_F(LocatorImplTest, locatorImplRegisterLocatingRequiredDataCallback001, TestSize.Level1)
545 {
546 GTEST_LOG_(INFO)
547 << "LocatorImplTest, locatorImplRegisterLocatingRequiredDataCallback001, TestSize.Level1";
548 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterLocatingRequiredDataCallback001 begin");
549 auto singleCallbackHost =
550 sptr<LocatingRequiredDataCallbackNapi>(new (std::nothrow) LocatingRequiredDataCallbackNapi());
551 if (singleCallbackHost) {
552 singleCallbackHost->SetFixNumber(1);
553 }
554 std::unique_ptr<LocatingRequiredDataConfig> requestConfig = std::make_unique<LocatingRequiredDataConfig>();
555 auto callbackPtr = sptr<ILocatingRequiredDataCallback>(singleCallbackHost);
556 locatorImpl_->RegisterLocatingRequiredDataCallback(requestConfig, callbackPtr);
557 locatorImpl_->UnRegisterLocatingRequiredDataCallback(callbackPtr);
558 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterLocatingRequiredDataCallback001 end");
559 }
560
561 HWTEST_F(LocatorImplTest, locatorImplUnRegisterLocatingRequiredDataCallback001, TestSize.Level1)
562 {
563 GTEST_LOG_(INFO)
564 << "LocatorImplTest, locatorImplUnRegisterLocatingRequiredDataCallback001, TestSize.Level1";
565 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnRegisterLocatingRequiredDataCallback001 begin");
566 auto singleCallbackHost =
567 sptr<LocatingRequiredDataCallbackNapi>(new (std::nothrow) LocatingRequiredDataCallbackNapi());
568 if (singleCallbackHost) {
569 singleCallbackHost->SetFixNumber(1);
570 }
571 auto callbackPtr = sptr<ILocatingRequiredDataCallback>(singleCallbackHost);
572 locatorImpl_->UnRegisterLocatingRequiredDataCallback(callbackPtr);
573 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnRegisterLocatingRequiredDataCallback001 end");
574 }
575
576 HWTEST_F(LocatorImplTest, locatorImplSubscribeBluetoothScanResultChange001, TestSize.Level1)
577 {
578 GTEST_LOG_(INFO)
579 << "LocatorImplTest, locatorImplSubscribeBluetoothScanResultChange001, TestSize.Level1";
580 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeBluetoothScanResultChange001 begin");
581 auto bluetoothScanResultCallbackHost =
582 sptr<BluetoothScanResultCallbackNapi>(new (std::nothrow) BluetoothScanResultCallbackNapi());
583 auto bluetoothScanResultCallback = sptr<IBluetoothScanResultCallback>(bluetoothScanResultCallbackHost);
584 locatorImpl_->SubscribeBluetoothScanResultChange(bluetoothScanResultCallback);
585 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeBluetoothScanResultChange001 end");
586 }
587
588 HWTEST_F(LocatorImplTest, locatorImplSubscribeBluetoothScanResultChange002, TestSize.Level1)
589 {
590 GTEST_LOG_(INFO)
591 << "LocatorImplTest, locatorImplSubscribeBluetoothScanResultChange002, TestSize.Level1";
592 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeBluetoothScanResultChange002 begin");
593 auto bluetoothScanResultCallbackHost =
594 sptr<BluetoothScanResultCallbackNapi>(new (std::nothrow) BluetoothScanResultCallbackNapi());
595 auto bluetoothScanResultCallback = sptr<IBluetoothScanResultCallback>(bluetoothScanResultCallbackHost);
596 bluetoothScanResultCallback = nullptr;
597 locatorImpl_->SubscribeBluetoothScanResultChange(bluetoothScanResultCallback);
598 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeBluetoothScanResultChange002 end");
599 }
600
601 HWTEST_F(LocatorImplTest, locatorImplUnSubscribeBluetoothScanResultChange001, TestSize.Level1)
602 {
603 GTEST_LOG_(INFO)
604 << "LocatorImplTest, locatorImplUnSubscribeBluetoothScanResultChange001, TestSize.Level1";
605 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeBluetoothScanResultChange001 begin");
606 auto bluetoothScanResultCallbackHost =
607 sptr<BluetoothScanResultCallbackNapi>(new (std::nothrow) BluetoothScanResultCallbackNapi());
608 auto bluetoothScanResultCallback = sptr<IBluetoothScanResultCallback>(bluetoothScanResultCallbackHost);
609 locatorImpl_->UnSubscribeBluetoothScanResultChange(bluetoothScanResultCallback);
610 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeBluetoothScanResultChange001 end");
611 }
612
613 HWTEST_F(LocatorImplTest, locatorImplUnSubscribeBluetoothScanResultChange002, TestSize.Level1)
614 {
615 GTEST_LOG_(INFO)
616 << "LocatorImplTest, locatorImplUnSubscribeBluetoothScanResultChange002, TestSize.Level1";
617 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeBluetoothScanResultChange002 begin");
618 auto bluetoothScanResultCallbackHost =
619 sptr<BluetoothScanResultCallbackNapi>(new (std::nothrow) BluetoothScanResultCallbackNapi());
620 auto bluetoothScanResultCallback = sptr<IBluetoothScanResultCallback>(bluetoothScanResultCallbackHost);
621 bluetoothScanResultCallback = nullptr;
622 locatorImpl_->UnSubscribeBluetoothScanResultChange(bluetoothScanResultCallback);
623 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeBluetoothScanResultChange002 end");
624 }
625
626 HWTEST_F(LocatorImplTest, locatorImplUpdateCallbackResumingState001, TestSize.Level1)
627 {
628 GTEST_LOG_(INFO)
629 << "LocatorImplTest, locatorImplUpdateCallbackResumingState001, TestSize.Level1";
630 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUpdateCallbackResumingState001 begin");
631 locatorImpl_->UpdateCallbackResumingState(true);
632 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUpdateCallbackResumingState001 end");
633 }
634
635 HWTEST_F(LocatorImplTest, locatorImplIsCallbackResuming001, TestSize.Level1)
636 {
637 GTEST_LOG_(INFO)
638 << "LocatorImplTest, locatorImplIsCallbackResuming001, TestSize.Level1";
639 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsCallbackResuming001 begin");
640 locatorImpl_->IsCallbackResuming();
641 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsCallbackResuming001 end");
642 }
643
644 HWTEST_F(LocatorImplTest, locatorImplIsLocationCallbackRegistered001, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO)
647 << "LocatorImplTest, locatorImplIsLocationCallbackRegistered001, TestSize.Level1";
648 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationCallbackRegistered001 begin");
649 auto locatorCallbackHostForTest =
650 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
651
652 if (locatorCallbackHostForTest) {
653 locatorCallbackHostForTest->SetFixNumber(1);
654 }
655 std::unique_ptr<RequestConfig> requestConfigPtr = std::make_unique<RequestConfig>();
656 requestConfigPtr->SetScenario(SCENE_NAVIGATION);
657 sptr<ILocatorCallback> callbackPtr = sptr<ILocatorCallback>(locatorCallbackHostForTest);
658 locatorImpl_->AddLocationCallBack(requestConfigPtr, callbackPtr);
659 locatorImpl_->IsLocationCallbackRegistered(callbackPtr);
660 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationCallbackRegistered001 end");
661 }
662
663 HWTEST_F(LocatorImplTest, locatorImplIsLocationCallbackRegistered002, TestSize.Level1)
664 {
665 GTEST_LOG_(INFO)
666 << "LocatorImplTest, locatorImplIsLocationCallbackRegistered002, TestSize.Level1";
667 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationCallbackRegistered002 begin");
668 sptr<IRemoteObject> callback;
669 locatorImpl_->AddSatelliteStatusChangeCallBack(callback);
670 locatorImpl_->IsSatelliteStatusChangeCallbackRegistered(callback);
671 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationCallbackRegistered002 end");
672 }
673
674 HWTEST_F(LocatorImplTest, locatorImplIsNmeaCallbackRegistered001, TestSize.Level1)
675 {
676 GTEST_LOG_(INFO)
677 << "LocatorImplTest, locatorImplIsNmeaCallbackRegistered001, TestSize.Level1";
678 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsNmeaCallbackRegistered001 begin");
679 sptr<IRemoteObject> callback;
680 locatorImpl_->AddNmeaCallBack(callback);
681 locatorImpl_->IsNmeaCallbackRegistered(callback);
682 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsNmeaCallbackRegistered001 end");
683 }
684
685 HWTEST_F(LocatorImplTest, locatorImplHasGnssNetworkRequest001, TestSize.Level1)
686 {
687 GTEST_LOG_(INFO)
688 << "LocatorImplTest, locatorImplHasGnssNetworkRequest001, TestSize.Level1";
689 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplHasGnssNetworkRequest001 begin");
690 auto locatorCallbackHostForTest =
691 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
692
693 if (locatorCallbackHostForTest) {
694 locatorCallbackHostForTest->SetFixNumber(1);
695 }
696 std::unique_ptr<RequestConfig> requestConfigPtr = std::make_unique<RequestConfig>();
697 requestConfigPtr->SetScenario(SCENE_NAVIGATION);
698 sptr<ILocatorCallback> callbackPtr = sptr<ILocatorCallback>(locatorCallbackHostForTest);
699 locatorImpl_->AddLocationCallBack(requestConfigPtr, callbackPtr);
700 locatorImpl_->HasGnssNetworkRequest();
701 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplHasGnssNetworkRequest001 end");
702 }
703
704 HWTEST_F(LocatorImplTest, locatorImplResumeGnssStatusCallback001, TestSize.Level1)
705 {
706 GTEST_LOG_(INFO)
707 << "LocatorImplTest, locatorImplResumeGnssStatusCallback001, TestSize.Level1";
708 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeGnssStatusCallback001 begin");
709 sptr<IRemoteObject> callback;
710 locatorImpl_->AddSatelliteStatusChangeCallBack(callback);
711 std::shared_ptr<CallbackResumeManager> callbackResumer = std::make_shared<CallbackResumeManager>();
712 callbackResumer->ResumeCallback();
713 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeGnssStatusCallback001 end");
714 }
715
716 HWTEST_F(LocatorImplTest, locatorImplResumeNmeaMessageCallback001, TestSize.Level1)
717 {
718 GTEST_LOG_(INFO)
719 << "LocatorImplTest, locatorImplResumeNmeaMessageCallback001, TestSize.Level1";
720 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeNmeaMessageCallback001 begin");
721 sptr<IRemoteObject> callback;
722 locatorImpl_->AddNmeaCallBack(callback);
723 std::shared_ptr<CallbackResumeManager> callbackResumer = std::make_shared<CallbackResumeManager>();
724 callbackResumer->ResumeCallback();
725 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeNmeaMessageCallback001 end");
726 }
727
728 HWTEST_F(LocatorImplTest, locatorImplResumeLocating001, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO)
731 << "LocatorImplTest, locatorImplResumeLocating001, TestSize.Level1";
732 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeLocating001 begin");
733 auto locatorCallbackHostForTest =
734 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
735
736 if (locatorCallbackHostForTest) {
737 locatorCallbackHostForTest->SetFixNumber(1);
738 }
739 std::unique_ptr<RequestConfig> requestConfigPtr = std::make_unique<RequestConfig>();
740 requestConfigPtr->SetScenario(SCENE_NAVIGATION);
741 sptr<ILocatorCallback> callbackPtr = sptr<ILocatorCallback>(locatorCallbackHostForTest);
742 locatorImpl_->AddLocationCallBack(requestConfigPtr, callbackPtr);
743 std::shared_ptr<CallbackResumeManager> callbackResumer = std::make_shared<CallbackResumeManager>();
744 callbackResumer->ResumeCallback();
745 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplResumeLocating001 end");
746 }
747
748 HWTEST_F(LocatorImplTest, locatorImplSubscribeLocationError001, TestSize.Level1)
749 {
750 GTEST_LOG_(INFO)
751 << "LocatorImplTest, locatorImplSubscribeLocationError001, TestSize.Level1";
752 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeLocationError001 begin");
753 auto locatorCallbackHostForTest =
754 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
755
756 if (locatorCallbackHostForTest) {
757 locatorCallbackHostForTest->SetFixNumber(1);
758 }
759 sptr<ILocatorCallback> callbackPtr = sptr<ILocatorCallback>(locatorCallbackHostForTest);
760 locatorImpl_->SubscribeLocationError(callbackPtr);
761 locatorImpl_->UnSubscribeLocationError(callbackPtr);
762 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplSubscribeLocationError001 end");
763 }
764
765 HWTEST_F(LocatorImplTest, locatorImplUnSubscribeLocationError001, TestSize.Level1)
766 {
767 GTEST_LOG_(INFO)
768 << "LocatorImplTest, locatorImplUnSubscribeLocationError001, TestSize.Level1";
769 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeLocationError001 begin");
770 auto locatorCallbackHostForTest =
771 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
772
773 if (locatorCallbackHostForTest) {
774 locatorCallbackHostForTest->SetFixNumber(1);
775 }
776 sptr<ILocatorCallback> callbackPtr = sptr<ILocatorCallback>(locatorCallbackHostForTest);
777 locatorImpl_->UnSubscribeLocationError(callbackPtr);
778 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplUnSubscribeLocationError001 end");
779 }
780
TestLocationUpdate(const std::unique_ptr<OHOS::Location::Location> & location)781 static void TestLocationUpdate(
782 const std::unique_ptr<OHOS::Location::Location>& location)
783 {
784 LBSLOGI(LOCATOR, "[LocatorImplTest] LocationUpdate enter");
785 EXPECT_EQ(true, location != nullptr);
786 }
787
TestSvStatusCallback(const std::unique_ptr<OHOS::Location::SatelliteStatus> & statusInfo)788 static void TestSvStatusCallback(
789 const std::unique_ptr<OHOS::Location::SatelliteStatus>& statusInfo)
790 {
791 LBSLOGI(LOCATOR, "[LocatorImplTest] SvStatusCallback begin");
792 EXPECT_EQ(true, statusInfo != nullptr);
793 LBSLOGI(LOCATOR, "[LocatorImplTest] SvStatusCallback end");
794 }
795
TestNmeaCallback(int64_t timestamp,const std::string msg)796 static void TestNmeaCallback(int64_t timestamp, const std::string msg)
797 {
798 LBSLOGI(LOCATOR, "[LocatorImplTest] NmeaCallback begin");
799 EXPECT_EQ(true, msg != "");
800 LBSLOGI(LOCATOR, "[LocatorImplTest] NmeaCallback end");
801 }
802
803 HWTEST_F(LocatorImplTest, locatorAgentTest1, TestSize.Level1)
804 {
805 GTEST_LOG_(INFO)
806 << "LocatorImplTest, locatorAgentTest1, TestSize.Level1";
807 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorAgentTest1 begin");
808 auto locatorAgent =
809 LocatorAgentManager::GetInstance();
810 ASSERT_TRUE(locatorAgent != nullptr);
811 static OHOS::Location::LocationCallbackIfaces locationCallback;
812 locationCallback.locationUpdate = TestLocationUpdate;
813 locatorAgent->StartGnssLocating(locationCallback);
814 sleep(1);
815 static OHOS::Location::SvStatusCallbackIfaces svCallback;
816 svCallback.svStatusUpdate = TestSvStatusCallback;
817 locatorAgent->RegisterGnssStatusCallback(svCallback);
818 sleep(1);
819 static OHOS::Location::GnssNmeaCallbackIfaces nmeaCallback;
820 nmeaCallback.nmeaUpdate = TestNmeaCallback;
821 locatorAgent->RegisterNmeaMessageCallback(nmeaCallback);
822 sleep(1);
823
824 locatorAgent->UnregisterNmeaMessageCallback();
825 locatorAgent->UnregisterGnssStatusCallback();
826 locatorAgent->StopGnssLocating();
827 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorAgentTest1 end");
828 }
829
830 HWTEST_F(LocatorImplTest, locatorImplCheckEdmPolicy001, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO)
833 << "LocatorImplTest, locatorImplCheckEdmPolicy001, TestSize.Level1";
834 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplCheckEdmPolicy001 begin");
835 locatorImpl_->CheckEdmPolicy(true);
836 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplCheckEdmPolicy001 end");
837 }
838
839 HWTEST_F(LocatorImplTest, locatorImplCheckEdmPolicy002, TestSize.Level1)
840 {
841 GTEST_LOG_(INFO)
842 << "LocatorImplTest, locatorImplCheckEdmPolicy002, TestSize.Level1";
843 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplCheckEdmPolicy002 begin");
844 locatorImpl_->CheckEdmPolicy(false);
845 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplCheckEdmPolicy002 end");
846 }
847
848 HWTEST_F(LocatorImplTest, CallbackResumeManager001, TestSize.Level1)
849 {
850 GTEST_LOG_(INFO)
851 << "LocatorImplTest, CallbackResumeManager001, TestSize.Level1";
852 LBSLOGI(LOCATOR, "[LocatorImplTest] CallbackResumeManager001 begin");
853 std::shared_ptr<CallbackResumeManager> callbackResumer = std::make_shared<CallbackResumeManager>();
854 callbackResumer->ResumeCallback();
855 LBSLOGI(LOCATOR, "[LocatorImplTest] CallbackResumeManager001 end");
856 }
857
858 HWTEST_F(LocatorImplTest, OnAddSystemAbility001, TestSize.Level1)
859 {
860 GTEST_LOG_(INFO)
861 << "LocatorImplTest, OnAddSystemAbility001, TestSize.Level1";
862 LBSLOGI(LOCATOR, "[LocatorImplTest] OnAddSystemAbility001 begin");
863 auto saStatusListener = sptr<LocatorSystemAbilityListener>(new LocatorSystemAbilityListener());
864 saStatusListener->OnAddSystemAbility(0, "deviceId");
865 LBSLOGI(LOCATOR, "[LocatorImplTest] OnAddSystemAbility001 end");
866 }
867
868 HWTEST_F(LocatorImplTest, OnAddSystemAbility002, TestSize.Level1)
869 {
870 GTEST_LOG_(INFO)
871 << "LocatorImplTest, OnAddSystemAbility002, TestSize.Level1";
872 LBSLOGI(LOCATOR, "[LocatorImplTest] OnAddSystemAbility001 begin");
873 auto saStatusListener = sptr<LocatorSystemAbilityListener>(new LocatorSystemAbilityListener());
874 saStatusListener->OnRemoveSystemAbility(0, "deviceId");
875 saStatusListener->OnAddSystemAbility(0, "deviceId");
876 LBSLOGI(LOCATOR, "[LocatorImplTest] OnAddSystemAbility002 end");
877 }
878
879 HWTEST_F(LocatorImplTest, OnRemoveSystemAbility001, TestSize.Level1)
880 {
881 GTEST_LOG_(INFO)
882 << "LocatorImplTest, OnRemoveSystemAbility001, TestSize.Level1";
883 LBSLOGI(LOCATOR, "[LocatorImplTest] OnRemoveSystemAbility001 begin");
884 auto saStatusListener = sptr<LocatorSystemAbilityListener>(new LocatorSystemAbilityListener());
885 saStatusListener->OnRemoveSystemAbility(0, "deviceId");
886 LBSLOGI(LOCATOR, "[LocatorImplTest] OnRemoveSystemAbility001 end");
887 }
888
889 HWTEST_F(LocatorImplTest, HasGnssNetworkRequest001, TestSize.Level1)
890 {
891 GTEST_LOG_(INFO)
892 << "LocatorImplTest, HasGnssNetworkRequest001, TestSize.Level1";
893 LBSLOGI(LOCATOR, "[LocatorImplTest] HasGnssNetworkRequest001 begin");
894 locatorImpl_->HasGnssNetworkRequest();
895 LBSLOGI(LOCATOR, "[LocatorImplTest] HasGnssNetworkRequest001 end");
896 }
897
898 HWTEST_F(LocatorImplTest, locatorImplEnableAbilityForUser001, TestSize.Level1)
899 {
900 GTEST_LOG_(INFO)
901 << "LocatorImplTest, locatorImplEnableAbilityForUser001, TestSize.Level1";
902 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityForUser001 begin");
903 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityForUser(false, DEFAULT_USER));
904 bool isEnabled = false;
905 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->IsLocationEnabledForUser(isEnabled, DEFAULT_USER));
906 EXPECT_EQ(false, isEnabled);
907 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityForUser(true, DEFAULT_USER));
908 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityForUser001 end");
909 }
910
911 HWTEST_F(LocatorImplTest, locatorImplEnableAbilityForUser002, TestSize.Level1)
912 {
913 GTEST_LOG_(INFO)
914 << "LocatorImplTest, locatorImplEnableAbilityForUser002, TestSize.Level1";
915 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityForUser002 begin");
916 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityForUser(false, DEFAULT_USER));
917 LocationDataRdbManager::SetSwitchStateToDbForUser(2, DEFAULT_USER);
918 sleep(1);
919 bool isEnabled = false;
920 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->IsLocationEnabledForUser(isEnabled, DEFAULT_USER));
921 EXPECT_EQ(false, isEnabled);
922 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl_->EnableAbilityForUser(true, DEFAULT_USER));
923 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplEnableAbilityForUser002 end");
924 }
925
926 HWTEST_F(LocatorImplTest, locatorImplIsLocationEnabledV9001, TestSize.Level1)
927 {
928 GTEST_LOG_(INFO)
929 << "LocatorImplTest, locatorImplIsLocationEnabledV9001, TestSize.Level1";
930 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationEnabledV9001 begin");
931 LocationDataRdbManager::SetSwitchStateToSysparaForCurrentUser(2);
932 bool isEnabled = false;
933 locatorImpl_->IsLocationEnabledV9(isEnabled);
934 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsLocationEnabledV9001 end");
935 }
936
937 HWTEST_F(LocatorImplTest, GetCurrentWifiBssidForLocating, TestSize.Level1)
938 {
939 GTEST_LOG_(INFO)
940 << "LocatorImplTest, GetCurrentWifiBssidForLocating, TestSize.Level1";
941 LBSLOGI(LOCATOR, "[LocatorImplTest] GetCurrentWifiBssidForLocating begin");
942 std::string bssid;
943 auto errCode = locatorImpl_->GetCurrentWifiBssidForLocating(bssid);
944 if (errCode == ERRCODE_SUCCESS) {
945 EXPECT_NE(0, bssid.size());
946 } else {
947 EXPECT_EQ(0, bssid.size());
948 }
949 LBSLOGI(LOCATOR, "[LocatorImplTest] GetCurrentWifiBssidForLocating end");
950 }
951
952 HWTEST_F(LocatorImplTest, IsPoiServiceSupported, TestSize.Level1)
953 {
954 GTEST_LOG_(INFO)
955 << "LocatorImplTest, IsPoiServiceSupported, TestSize.Level1";
956 LBSLOGI(LOCATOR, "[LocatorImplTest] IsPoiServiceSupported begin");
957 bool poiServiceSupportState = false;
958 poiServiceSupportState = locatorImpl_->IsPoiServiceSupported();
959 LBSLOGI(LOCATOR, "[LocatorImplTest] IsPoiServiceSupported end");
960 }
961
962 HWTEST_F(LocatorImplTest, SetLocationSwitchIgnored001, TestSize.Level1)
963 {
964 GTEST_LOG_(INFO)
965 << "LocatorImplTest, SetLocationSwitchIgnored001, TestSize.Level1";
966 LBSLOGI(LOCATOR, "[LocatorImplTest] SetLocationSwitchIgnored001 begin");
967 std::string bssid;
968 auto errCode = locatorImpl_->SetLocationSwitchIgnored(true);
969 EXPECT_EQ(ERRCODE_SUCCESS, errCode);
970 LBSLOGI(LOCATOR, "[LocatorImplTest] SetLocationSwitchIgnored001 end");
971 }
972
973 HWTEST_F(LocatorImplTest, SetLocationSwitchIgnored002, TestSize.Level1)
974 {
975 GTEST_LOG_(INFO)
976 << "LocatorImplTest, SetLocationSwitchIgnored002, TestSize.Level1";
977 LBSLOGI(LOCATOR, "[LocatorImplTest] SetLocationSwitchIgnored002 begin");
978 std::string bssid;
979 auto errCode = locatorImpl_->SetLocationSwitchIgnored(false);
980 EXPECT_EQ(ERRCODE_SUCCESS, errCode);
981 LBSLOGI(LOCATOR, "[LocatorImplTest] SetLocationSwitchIgnored002 end");
982 }
983
984 /*
985 * @tc.name: CheckLocatingForScenario001
986 * @tc.desc: Check start locating based on scenario expect success
987 * @tc.type: FUNC
988 */
989 HWTEST_F(LocatorImplTest, CheckLocatingForScenario001, TestSize.Level1)
990 {
991 /*
992 * @tc.steps: step1. Call system ability and start locating for SCENE_VEHICLE_NAVIGATION.
993 * @tc.expected: step1. get reply state is successful.
994 */
995 GTEST_LOG_(INFO)
996 << "LocatorImplTest, CheckLocatingForScenario001, TestSize.Level1";
997 LBSLOGI(LOCATOR, "[LocatorImplTest] CheckLocatingForScenario001 begin");
998 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
999 requestConfig->SetScenario(SCENE_NAVIGATION);
1000 auto locatorImpl = Locator::GetInstance();
1001 locatorImpl->StartLocating(requestConfig, callbackStub_);
1002 locatorImpl->StopLocating(callbackStub_);
1003 LBSLOGI(LOCATOR, "[LocatorImplTest] CheckLocatingForScenario001 end");
1004 }
1005
1006 /*
1007 * @tc.name: CheckStopLocating001
1008 * @tc.desc: Check stop locating with illegal param and expect fail
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(LocatorImplTest, CheckStopLocating001, TestSize.Level1)
1012 {
1013 /*
1014 * @tc.steps: step1. Call system ability and stop locating whit illegal param.
1015 * @tc.expected: step1. get reply state is false.
1016 */
1017 GTEST_LOG_(INFO)
1018 << "LocatorImplTest, CheckStopLocating001, TestSize.Level1";
1019 LBSLOGI(LOCATOR, "[LocatorImplTest] CheckStopLocating001 begin");
1020 auto locatorImpl = Locator::GetInstance();
1021 ASSERT_TRUE(locatorImpl != nullptr);
1022 locatorImpl->StopLocating(callbackStub_);
1023 LBSLOGI(LOCATOR, "[LocatorImplTest] CheckStopLocating001 end");
1024 }
1025
1026 HWTEST_F(LocatorImplTest, locatorImpl001, TestSize.Level1)
1027 {
1028 GTEST_LOG_(INFO)
1029 << "LocatorImplTest, locatorImpl001, TestSize.Level1";
1030 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImpl001 begin");
1031 auto locatorImpl = Locator::GetInstance();
1032 EXPECT_NE(nullptr, locatorImpl);
1033 locatorImpl->ShowNotification();
1034 locatorImpl->RequestPermission();
1035 locatorImpl->RequestEnableLocation();
1036
1037 locatorImpl->EnableAbility(false);
1038 EXPECT_EQ(false, locatorImpl->IsLocationEnabled());
1039 locatorImpl->EnableAbility(true);
1040
1041 locatorImpl->GetCachedLocation();
1042
1043 locatorImpl->SetLocationPrivacyConfirmStatus(1, true);
1044 EXPECT_EQ(true, locatorImpl->IsLocationPrivacyConfirmed(1));
1045 locatorImpl->SetLocationPrivacyConfirmStatus(-1, true);
1046 locatorImpl->IsLocationPrivacyConfirmed(-1);
1047 #ifdef FEATURE_GNSS_SUPPORT
1048 EXPECT_EQ(0, locatorImpl->GetCachedGnssLocationsSize());
1049 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, locatorImpl->FlushCachedGnssLocations());
1050 std::unique_ptr<LocationCommand> command = std::make_unique<LocationCommand>();
1051 command->scenario = SCENE_NAVIGATION;
1052 command->command = "cmd";
1053 EXPECT_EQ(true, locatorImpl->SendCommand(command));
1054 #endif
1055 EXPECT_NE(nullptr, locatorImpl->GetIsoCountryCode());
1056 int timeInterval = 2;
1057 locatorImpl->EnableLocationMock();
1058 std::vector<std::shared_ptr<Location>> locations;
1059 locatorImpl->SetMockedLocations(timeInterval, locations);
1060 locatorImpl->DisableLocationMock();
1061 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImpl001 end");
1062 }
1063
1064 #ifdef FEATURE_GEOCODE_SUPPORT
1065 HWTEST_F(LocatorImplTest, locatorImplGeocodingMock001, TestSize.Level1)
1066 {
1067 GTEST_LOG_(INFO)
1068 << "LocatorImplTest, locatorImplGeocodingMock001, TestSize.Level1";
1069 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGeocodingMock001 begin");
1070 auto locatorImpl = Locator::GetInstance();
1071 EXPECT_NE(nullptr, locatorImpl);
1072 locatorImpl->EnableReverseGeocodingMock();
1073 std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfos = SetGeocodingMockInfo();
1074 locatorImpl->SetReverseGeocodingMockInfo(mockInfos);
1075 locatorImpl->DisableReverseGeocodingMock();
1076 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGeocodingMock001 end");
1077 }
1078 #endif
1079
1080 #ifdef FEATURE_GEOCODE_SUPPORT
1081 HWTEST_F(LocatorImplTest, locatorImplGetAddressByCoordinate001, TestSize.Level1)
1082 {
1083 GTEST_LOG_(INFO)
1084 << "LocatorImplTest, locatorImplGetAddressByCoordinate001, TestSize.Level1";
1085 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinate001 begin");
1086 auto locatorImpl = Locator::GetInstance();
1087 EXPECT_NE(nullptr, locatorImpl);
1088 MessageParcel request001;
1089 std::list<std::shared_ptr<GeoAddress>> geoAddressList001;
1090 locatorImpl->EnableReverseGeocodingMock();
1091
1092 std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfos = SetGeocodingMockInfo();
1093 locatorImpl->SetReverseGeocodingMockInfo(mockInfos);
1094 request001.WriteInterfaceToken(LocatorProxy::GetDescriptor());
1095 request001.WriteDouble(MOCK_LATITUDE); // latitude
1096 request001.WriteDouble(MOCK_LONGITUDE); // longitude
1097 request001.WriteInt32(3); // maxItems
1098 request001.WriteInt32(1); // locale object size = 1
1099 request001.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
1100 request001.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
1101 request001.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
1102 request001.WriteString16(Str8ToStr16("")); // ""
1103 locatorImpl->GetAddressByCoordinate(request001, geoAddressList001);
1104 EXPECT_EQ(true, geoAddressList001.empty());
1105 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinate001 end");
1106 }
1107 #endif
1108
1109 #ifdef FEATURE_GEOCODE_SUPPORT
1110 HWTEST_F(LocatorImplTest, locatorImplGetAddressByCoordinate002, TestSize.Level1)
1111 {
1112 GTEST_LOG_(INFO)
1113 << "LocatorImplTest, locatorImplGetAddressByCoordinate002, TestSize.Level1";
1114 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinate002 begin");
1115 auto locatorImpl = Locator::GetInstance();
1116 EXPECT_NE(nullptr, locatorImpl);
1117 MessageParcel request002;
1118 std::list<std::shared_ptr<GeoAddress>> geoAddressList002;
1119 locatorImpl->DisableReverseGeocodingMock();
1120 request002.WriteInterfaceToken(LocatorProxy::GetDescriptor());
1121 request002.WriteDouble(1.0); // latitude
1122 request002.WriteDouble(2.0); // longitude
1123 request002.WriteInt32(3); // maxItems
1124 request002.WriteInt32(1); // locale object size = 1
1125 request002.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
1126 request002.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
1127 request002.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
1128 request002.WriteString16(Str8ToStr16("")); // ""
1129 locatorImpl->GetAddressByCoordinate(request002, geoAddressList002);
1130 EXPECT_EQ(true, geoAddressList002.empty());
1131 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByCoordinate002 end");
1132 }
1133 #endif
1134
1135 #ifdef FEATURE_GEOCODE_SUPPORT
1136 HWTEST_F(LocatorImplTest, locatorImplGetAddressByLocationName001, TestSize.Level1)
1137 {
1138 GTEST_LOG_(INFO)
1139 << "LocatorImplTest, locatorImplGetAddressByLocationName001, TestSize.Level1";
1140 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByLocationName001 begin");
1141 auto locatorImpl = Locator::GetInstance();
1142 EXPECT_NE(nullptr, locatorImpl);
1143 MessageParcel request003;
1144 std::list<std::shared_ptr<GeoAddress>> geoAddressList003;
1145 request003.WriteInterfaceToken(LocatorProxy::GetDescriptor());
1146 request003.WriteString16(Str8ToStr16("description")); // description
1147 request003.WriteDouble(1.0); // minLatitude
1148 request003.WriteDouble(2.0); // minLongitude
1149 request003.WriteDouble(3.0); // maxLatitude
1150 request003.WriteDouble(4.0); // maxLongitude
1151 request003.WriteInt32(3); // maxItems
1152 request003.WriteInt32(1); // locale object size = 1
1153 request003.WriteString16(Str8ToStr16("Language")); // locale.getLanguage()
1154 request003.WriteString16(Str8ToStr16("Country")); // locale.getCountry()
1155 request003.WriteString16(Str8ToStr16("Variant")); // locale.getVariant()
1156 request003.WriteString16(Str8ToStr16("")); // ""
1157 locatorImpl->GetAddressByLocationName(request003, geoAddressList003);
1158 EXPECT_EQ(true, geoAddressList003.empty());
1159 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplGetAddressByLocationName001 end");
1160 }
1161 #endif
1162
1163 HWTEST_F(LocatorImplTest, locatorImplRegisterAndUnregisterCallback001, TestSize.Level1)
1164 {
1165 GTEST_LOG_(INFO)
1166 << "LocatorImplTest, locatorImplRegisterAndUnregisterCallback001, TestSize.Level1";
1167 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterAndUnregisterCallback001 begin");
1168 auto locatorImpl = Locator::GetInstance();
1169 EXPECT_NE(nullptr, locatorImpl);
1170 auto switchCallbackHost =
1171 sptr<LocationSwitchCallbackNapi>(new (std::nothrow) LocationSwitchCallbackNapi());
1172 EXPECT_NE(nullptr, switchCallbackHost);
1173 EXPECT_EQ(true, locatorImpl->RegisterSwitchCallback(switchCallbackHost->AsObject(), 1000));
1174 EXPECT_EQ(true, locatorImpl->UnregisterSwitchCallback(switchCallbackHost->AsObject()));
1175 #ifdef FEATURE_GNSS_SUPPORT
1176 auto gnssCallbackHost =
1177 sptr<GnssStatusCallbackNapi>(new (std::nothrow) GnssStatusCallbackNapi());
1178 EXPECT_NE(nullptr, gnssCallbackHost);
1179 EXPECT_EQ(true, locatorImpl->RegisterGnssStatusCallback(gnssCallbackHost->AsObject(), 1000));
1180 EXPECT_EQ(true, locatorImpl->UnregisterGnssStatusCallback(gnssCallbackHost->AsObject()));
1181 auto nmeaCallbackHost =
1182 sptr<NmeaMessageCallbackNapi>(new (std::nothrow) NmeaMessageCallbackNapi());
1183 EXPECT_NE(nullptr, nmeaCallbackHost);
1184 EXPECT_EQ(true, locatorImpl->RegisterNmeaMessageCallback(nmeaCallbackHost->AsObject(), 1000));
1185 EXPECT_EQ(true, locatorImpl->UnregisterNmeaMessageCallback(nmeaCallbackHost->AsObject()));
1186 #endif
1187 auto countryCodeCallbackHost =
1188 sptr<CountryCodeCallbackNapi>(new (std::nothrow) CountryCodeCallbackNapi());
1189 EXPECT_NE(nullptr, countryCodeCallbackHost);
1190 EXPECT_EQ(true, locatorImpl->RegisterCountryCodeCallback(countryCodeCallbackHost->AsObject(), 1000));
1191 EXPECT_EQ(true, locatorImpl->UnregisterCountryCodeCallback(countryCodeCallbackHost->AsObject()));
1192 #ifdef FEATURE_GNSS_SUPPORT
1193 auto cachedLocationsCallbackHost =
1194 sptr<CachedLocationsCallbackNapi>(new (std::nothrow) CachedLocationsCallbackNapi());
1195 EXPECT_NE(nullptr, cachedLocationsCallbackHost);
1196 auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
1197 EXPECT_NE(nullptr, cachedCallback);
1198 auto request = std::make_unique<CachedGnssLocationsRequest>();
1199 EXPECT_NE(nullptr, request);
1200 request->reportingPeriodSec = 10;
1201 request->wakeUpCacheQueueFull = true;
1202 locatorImpl->RegisterCachedLocationCallback(request, cachedCallback);
1203 locatorImpl->UnregisterCachedLocationCallback(cachedCallback);
1204 #endif
1205 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRegisterAndUnregisterCallback001 end");
1206 }
1207
1208 HWTEST_F(LocatorImplTest, locatorImplIsBeaconFenceSupported001, TestSize.Level1)
1209 {
1210 GTEST_LOG_(INFO)
1211 << "LocatorImplTest, locatorImplIsBeaconFenceSupported001, TestSize.Level1";
1212 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsBeaconFenceSupported001 begin");
1213 auto locatorImpl = Locator::GetInstance();
1214 EXPECT_NE(nullptr, locatorImpl);
1215 locatorImpl->IsBeaconFenceSupported();
1216 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplIsBeaconFenceSupported001 end");
1217 }
1218
1219 HWTEST_F(LocatorImplTest, locatorImplAddBeaconFence001, TestSize.Level1)
1220 {
1221 GTEST_LOG_(INFO)
1222 << "LocatorImplTest, locatorImplAddBeaconFence001, TestSize.Level1";
1223 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplAddBeaconFence001 begin");
1224 auto locatorImpl = Locator::GetInstance();
1225 EXPECT_NE(nullptr, locatorImpl);
1226 std::shared_ptr<BeaconFenceRequest> beaconFenceRequest = std::make_shared<BeaconFenceRequest>();
1227 std::shared_ptr<BeaconFence> beaconFence = std::make_shared<BeaconFence>();
1228 BeaconManufactureData manufactureData;
1229 manufactureData.manufactureId = 76;
1230 beaconFence->SetIdentifier("locatorImplAddBeaconFence001");
1231 beaconFence->SetBeaconFenceInfoType(BeaconFenceInfoType::BEACON_MANUFACTURE_DATA);
1232 beaconFence->SetBeaconManufactureData(manufactureData);
1233 beaconFenceRequest->SetBeaconFence(beaconFence);
1234 beaconFenceRequest->SetFenceExtensionAbilityName("ExtensionAbility");
1235 locatorImpl->AddBeaconFence(beaconFenceRequest);
1236 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplAddBeaconFence001 end");
1237 }
1238
1239 HWTEST_F(LocatorImplTest, locatorImplRemoveBeaconFence001, TestSize.Level1)
1240 {
1241 GTEST_LOG_(INFO)
1242 << "LocatorImplTest, locatorImplRemoveBeaconFence001, TestSize.Level1";
1243 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRemoveBeaconFence001 begin");
1244 auto locatorImpl = Locator::GetInstance();
1245 EXPECT_NE(nullptr, locatorImpl);
1246 std::shared_ptr<BeaconFence> beaconFence = std::make_shared<BeaconFence>();
1247 BeaconManufactureData manufactureData;
1248 manufactureData.manufactureId = 76;
1249 beaconFence->SetIdentifier("locatorImplRemoveBeaconFence001");
1250 beaconFence->SetBeaconFenceInfoType(BeaconFenceInfoType::BEACON_MANUFACTURE_DATA);
1251 beaconFence->SetBeaconManufactureData(manufactureData);
1252 locatorImpl->RemoveBeaconFence(beaconFence);
1253 LBSLOGI(LOCATOR, "[LocatorImplTest] locatorImplRemoveBeaconFence001 end");
1254 }
1255 } // namespace Location
1256 } // namespace OHOS
1257