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 "gnss_ability_test.h"
17
18 #include <cstdlib>
19
20 #include "accesstoken_kit.h"
21 #include "cell_information.h"
22 #include "if_system_ability_manager.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "nativetoken_kit.h"
26 #include "system_ability_definition.h"
27 #include "token_setproc.h"
28
29 #include "common_utils.h"
30 #include "constant_definition.h"
31 #include "gnss_event_callback.h"
32 #include "location_dumper.h"
33
34 #include "mock_i_cellular_data_manager.h"
35
36 using namespace testing;
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace Location {
41 using HDI::Location::Agnss::V1_0::IAGnssCallback;
42 using HDI::Location::Agnss::V1_0::AGnssRefInfo;
43 using HDI::Location::Gnss::V1_0::IGnssCallback;
44 using HDI::Location::Gnss::V1_0::LocationInfo;
45 const int32_t LOCATION_PERM_NUM = 4;
46 const std::string ARGS_HELP = "-h";
SetUp()47 void GnssAbilityTest::SetUp()
48 {
49 /*
50 * @tc.setup: Get system ability's pointer and get sa proxy object.
51 */
52 MockNativePermission();
53 ability_ = new (std::nothrow) GnssAbility();
54 EXPECT_NE(nullptr, ability_);
55 callbackStub_ = new (std::nothrow) GnssStatusCallbackHost();
56 EXPECT_NE(nullptr, callbackStub_);
57 proxy_ = new (std::nothrow) GnssAbilityProxy(ability_);
58 EXPECT_NE(nullptr, proxy_);
59 }
60
TearDown()61 void GnssAbilityTest::TearDown()
62 {
63 /*
64 * @tc.teardown: release memory.
65 */
66 proxy_ = nullptr;
67 callbackStub_ = nullptr;
68 }
69
MockNativePermission()70 void GnssAbilityTest::MockNativePermission()
71 {
72 const char *perms[] = {
73 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
74 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
75 };
76 NativeTokenInfoParams infoInstance = {
77 .dcapsNum = 0,
78 .permsNum = LOCATION_PERM_NUM,
79 .aclsNum = 0,
80 .dcaps = nullptr,
81 .perms = perms,
82 .acls = nullptr,
83 .processName = "GnssAbilityTest",
84 .aplStr = "system_basic",
85 };
86 uint64_t tokenId = GetAccessTokenId(&infoInstance);
87 SetSelfTokenID(tokenId);
88 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
89 }
90
91 /*
92 * @tc.name: SendLocationRequest001
93 * @tc.desc: Build Request, marshall and unmarshall data Then Send it
94 * @tc.type: FUNC
95 */
96 HWTEST_F(GnssAbilityTest, SendLocationRequest001, TestSize.Level1)
97 {
98 GTEST_LOG_(INFO)
99 << "GnssAbilityTest, SendLocationRequest001, TestSize.Level1";
100 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SendLocationRequest001 begin");
101 /*
102 * @tc.steps: step1. build location request data.
103 */
104 std::unique_ptr<WorkRecord> workRecord = std::make_unique<WorkRecord>();
105 int num = 2;
106 for (int i = 0; i < num; i++) {
107 int uid = i + 1;
108 int pid = i + 2;
109 int timeInterval = i;
110 std::string name = "nameForTest";
111 std::string uuid = std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM));
112 workRecord->Add(uid, pid, name, timeInterval, uuid);
113 }
114 /*
115 * @tc.steps: step2. send location request
116 * @tc.expected: step2. no exception happens.
117 */
118 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendLocationRequest(*workRecord));
119 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SendLocationRequest001 end");
120 }
121
122 /*
123 * @tc.name: SetEnableAndDisable001
124 * @tc.desc: Test disable and enable system ability
125 * @tc.type: FUNC
126 */
127 HWTEST_F(GnssAbilityTest, SetEnableAndDisable001, TestSize.Level1)
128 {
129 GTEST_LOG_(INFO)
130 << "GnssAbilityTest, SetEnableAndDisable001, TestSize.Level1";
131 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SetEnableAndDisable001 begin");
132 /*
133 * @tc.steps: step1.remove SA
134 * @tc.expected: step1. object1 is null.
135 */
136 MessageParcel data1;
137 data1.WriteBool(false); // if the state is false
138 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(data1.ReadBool()));
139 sptr<ISystemAbilityManager> systemAbilityManager1 =
140 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
141 sptr<IRemoteObject> object1 = systemAbilityManager1->GetSystemAbility(LOCATION_GNSS_SA_ID);
142 EXPECT_EQ(nullptr, object1); // no SA can be given
143
144 /*
145 * @tc.steps: step2. test enable SA
146 * @tc.expected: step2. object2 is not null.
147 */
148 MessageParcel data2;
149 data2.WriteBool(true); // if the state is true
150 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(data2.ReadBool()));
151 sptr<ISystemAbilityManager> systemAbilityManager2 =
152 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
153 sptr<IRemoteObject> object2 = systemAbilityManager2->GetSystemAbility(LOCATION_GNSS_SA_ID);
154 EXPECT_NE(nullptr, object2); // SA can be given
155 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SetEnableAndDisable001 end");
156 }
157
158 /*
159 * @tc.name: RefrashRequirements001
160 * @tc.desc: Test refrash requirements
161 * @tc.type: FUNC
162 */
163 HWTEST_F(GnssAbilityTest, RefrashRequirements001, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO)
166 << "GnssAbilityTest, RefrashRequirements001, TestSize.Level1";
167 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RefrashRequirements001 begin");
168 /*
169 * @tc.steps: step1. test refrash requirements
170 * @tc.expected: no exception happens.
171 */
172 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->RefrashRequirements());
173 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RefrashRequirements001 end");
174 }
175
176 /*
177 * @tc.name: RegisterGnssStatusCallback001
178 * @tc.desc: Test register gnss status callback if client is null
179 * @tc.type: FUNC
180 */
181 HWTEST_F(GnssAbilityTest, RegisterGnssStatusCallback001, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO)
184 << "GnssAbilityTest, RegisterGnssStatusCallback001, TestSize.Level1";
185 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterGnssStatusCallback001 begin");
186 /*
187 * @tc.steps: step1.the client is null.
188 */
189 pid_t lastCallingUid = 1;
190 sptr<IRemoteObject> client = nullptr;
191
192 /*
193 * @tc.steps: step2. test register gnss status callback
194 * @tc.expected: log info : "SendRegisterMsgToRemote callback is nullptr".
195 */
196 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->RegisterGnssStatusCallback(client, lastCallingUid));
197 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterGnssStatusCallback001 end");
198 }
199
200 /*
201 * @tc.name: RegisterAndUnregisterGnssStatusCallback001
202 * @tc.desc: Test register and unregister gnss status callback if client is not null
203 * @tc.type: FUNC
204 */
205 HWTEST_F(GnssAbilityTest, RegisterAndUnregisterGnssStatusCallback001, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO)
208 << "GnssAbilityTest, RegisterAndUnregisterGnssStatusCallback001, TestSize.Level1";
209 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterGnssStatusCallback001 begin");
210 /*
211 * @tc.steps: step1. give the last calling uid
212 */
213 pid_t lastCallingUid = 1;
214
215 /*
216 * @tc.steps: step2. test register gnss status callback
217 * @tc.expected: no exception happens.
218 */
219 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->RegisterGnssStatusCallback(callbackStub_->AsObject(), lastCallingUid));
220
221 /*
222 * @tc.steps: step3. test unregister gnss status callback
223 * @tc.expected: no exception happens
224 */
225 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->UnregisterGnssStatusCallback(callbackStub_->AsObject()));
226 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterGnssStatusCallback001 end");
227 }
228
229 /*
230 * @tc.name: UnregisterGnssStatusCallback001
231 * @tc.desc: Test unregister gnss status callback if client is null
232 * @tc.type: FUNC
233 */
234 HWTEST_F(GnssAbilityTest, UnregisterGnssStatusCallback001, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO)
237 << "GnssAbilityTest, UnregisterGnssStatusCallback001, TestSize.Level1";
238 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterGnssStatusCallback001 begin");
239 /*
240 * @tc.steps: step1.the client is null.
241 */
242 sptr<IRemoteObject> client = nullptr;
243
244 /*
245 * @tc.steps: step2. test unregister gnss status callback
246 * @tc.expected: log info : "unregister an invalid gnssStatus callback".
247 */
248 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->UnregisterGnssStatusCallback(client));
249 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterGnssStatusCallback001 end");
250 }
251
252 /*
253 * @tc.name: RegisterNmeaMessageCallback001
254 * @tc.desc: Test register nmea message callback if client is null
255 * @tc.type: FUNC
256 */
257 HWTEST_F(GnssAbilityTest, RegisterNmeaMessageCallback001, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO)
260 << "GnssAbilityTest, RegisterNmeaMessageCallback001, TestSize.Level1";
261 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterNmeaMessageCallback001 begin");
262 /*
263 * @tc.steps: step1.the client is null.
264 */
265 pid_t uid = 1;
266 sptr<IRemoteObject> client = nullptr;
267
268 /*
269 * @tc.steps: step2. test register nmea message callback
270 * @tc.expected: log info : "register an invalid nmea callback".
271 */
272 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->RegisterNmeaMessageCallback(client, uid));
273 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterNmeaMessageCallback001 end");
274 }
275
276 /*
277 * @tc.name: RegisterAndUnregisterNmeaMessageCallback001
278 * @tc.desc: Test register nmea message callback if client is not null
279 * @tc.type: FUNC
280 */
281 HWTEST_F(GnssAbilityTest, RegisterAndUnregisterNmeaMessageCallback001, TestSize.Level1)
282 {
283 GTEST_LOG_(INFO)
284 << "GnssAbilityTest, RegisterAndUnregisterNmeaMessageCallback001, TestSize.Level1";
285 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterNmeaMessageCallback001 begin");
286 /*
287 * @tc.steps: step1.the client is not null.
288 */
289 pid_t uid = 1;
290
291 /*
292 * @tc.steps: step2. test register nmea message callback
293 * @tc.expected: no exception happens
294 */
295 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->RegisterNmeaMessageCallback(callbackStub_->AsObject(), uid));
296
297 /*
298 * @tc.steps: step3. test unregister nmea message callback
299 * @tc.expected: no exception happens.
300 */
301 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->UnregisterNmeaMessageCallback(callbackStub_->AsObject()));
302 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterNmeaMessageCallback001 end");
303 }
304
305 /*
306 * @tc.name: UnregisterNmeaMessageCallback001
307 * @tc.desc: Test unregister nmea message callback if client is null
308 * @tc.type: FUNC
309 */
310 HWTEST_F(GnssAbilityTest, UnregisterNmeaMessageCallback001, TestSize.Level1)
311 {
312 GTEST_LOG_(INFO)
313 << "GnssAbilityTest, UnregisterNmeaMessageCallback001, TestSize.Level1";
314 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterNmeaMessageCallback001 begin");
315 /*
316 * @tc.steps: step1.the client is null.
317 */
318 sptr<IRemoteObject> client = nullptr;
319
320 /*
321 * @tc.steps: step2. test unregister nmea message callback
322 * @tc.expected: log info : "unregister an invalid nmea callback".
323 */
324 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->UnregisterNmeaMessageCallback(client));
325 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterNmeaMessageCallback001 end");
326 }
327
328 /*
329 * @tc.name: RegisterCachedCallback001
330 * @tc.desc: Test register cache call back
331 * @tc.type: FUNC
332 */
333 HWTEST_F(GnssAbilityTest, RegisterCachedCallback001, TestSize.Level1)
334 {
335 GTEST_LOG_(INFO)
336 << "GnssAbilityTest, RegisterCachedCallback001, TestSize.Level1";
337 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterCachedCallback001 begin");
338 /*
339 * @tc.steps: step1.prepare request config and the call back is null.
340 */
341 std::unique_ptr<CachedGnssLocationsRequest> requestConfig = std::make_unique<CachedGnssLocationsRequest>();
342 requestConfig->reportingPeriodSec = 100;
343 requestConfig->wakeUpCacheQueueFull = true;
344
345 sptr<IRemoteObject> callback = nullptr;
346
347 /*
348 * @tc.steps: step2. test register cached call back if call back is null.
349 * @tc.expected: log info : "register an invalid cached location callback"
350 */
351 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->RegisterCachedCallback(requestConfig, callback));
352 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterCachedCallback001 end");
353 }
354
355 /*
356 * @tc.name: RegisterCachedCallback002
357 * @tc.desc: Test register cache call back and the queue is not full.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(GnssAbilityTest, RegisterCachedCallback003, TestSize.Level1)
361 {
362 GTEST_LOG_(INFO)
363 << "GnssAbilityTest, RegisterCachedCallback003, TestSize.Level1";
364 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterCachedCallback003 begin");
365 /*
366 * @tc.steps: step1.prepare request config and the call back is not null.
367 */
368 std::unique_ptr<CachedGnssLocationsRequest> requestConfig = std::make_unique<CachedGnssLocationsRequest>();
369 requestConfig->reportingPeriodSec = 100;
370 requestConfig->wakeUpCacheQueueFull = false;
371
372 /*
373 * @tc.steps: step2. test register cached call back if call back is not null.
374 * @tc.expected: no exception happens
375 */
376 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->RegisterCachedCallback(requestConfig, callbackStub_->AsObject()));
377 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterCachedCallback003 end");
378 }
379
380 /*
381 * @tc.name: RegisterAndUnregisterCachedCallback001
382 * @tc.desc: Test register and unregister cache call back and the queue is full.
383 * @tc.type: FUNC
384 */
385 HWTEST_F(GnssAbilityTest, RegisterAndUnregisterCachedCallback002, TestSize.Level1)
386 {
387 GTEST_LOG_(INFO)
388 << "GnssAbilityTest, RegisterAndUnregisterCachedCallback002, TestSize.Level1";
389 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterCachedCallback002 begin");
390 /*
391 * @tc.steps: step1.prepare request config and the call back is not null.
392 */
393 std::unique_ptr<CachedGnssLocationsRequest> requestConfig = std::make_unique<CachedGnssLocationsRequest>();
394 requestConfig->reportingPeriodSec = 100;
395 requestConfig->wakeUpCacheQueueFull = true;
396
397 /*
398 * @tc.steps: step2. test register cached call back if call back is not null.
399 * @tc.expected: no exception happens
400 */
401 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->RegisterCachedCallback(requestConfig, callbackStub_->AsObject()));
402
403 /*
404 * @tc.steps: step3. test unregister cached call back if call back is not null.
405 * @tc.expected: no exception happens.
406 */
407 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->UnregisterCachedCallback(callbackStub_->AsObject()));
408 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RegisterAndUnregisterCachedCallback002 end");
409 }
410
411 /*
412 * @tc.name: UnregisterCachedCallback001
413 * @tc.desc: Test unregister cache call back and call back is null
414 * @tc.type: FUNC
415 */
416 HWTEST_F(GnssAbilityTest, UnregisterCachedCallback001, TestSize.Level1)
417 {
418 GTEST_LOG_(INFO)
419 << "GnssAbilityTest, UnregisterCachedCallback001, TestSize.Level1";
420 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterCachedCallback001 begin");
421 /*
422 * @tc.steps: step1. the call back is null.
423 */
424 sptr<IRemoteObject> callback = nullptr;
425
426 /*
427 * @tc.steps: step2. test unregister cached call back if call back is null.
428 * @tc.expected: log info : "register an invalid cached location callback"
429 */
430 EXPECT_EQ(ERRCODE_INVALID_PARAM, proxy_->UnregisterCachedCallback(callback));
431 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] UnregisterCachedCallback001 end");
432 }
433
434 /*
435 * @tc.name: GetCachedGnssLocationsSize001
436 * @tc.desc: Test get cached gnss locations size
437 * @tc.type: FUNC
438 */
439 HWTEST_F(GnssAbilityTest, GetCachedGnssLocationsSize001, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO)
442 << "GnssAbilityTest, GetCachedGnssLocationsSize001, TestSize.Level1";
443 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GetCachedGnssLocationsSize001 begin");
444 /*
445 * @tc.steps: step1. test get cached gnss locations size.
446 * @tc.expected: size equals -1.
447 */
448 int size = 0;
449 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->GetCachedGnssLocationsSize(size));
450 EXPECT_EQ(0, size);
451 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GetCachedGnssLocationsSize001 end");
452 }
453
454 /*
455 * @tc.name: FlushCachedGnssLocations001
456 * @tc.desc: Test unregister country code call back
457 * @tc.type: FUNC
458 */
459 HWTEST_F(GnssAbilityTest, FlushCachedGnssLocations001, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO)
462 << "GnssAbilityTest, FlushCachedGnssLocations001, TestSize.Level1";
463 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] FlushCachedGnssLocations001 begin");
464 /*
465 * @tc.steps: step1. test flush cached gnss locations.
466 * @tc.expected: reply code unsupport
467 */
468 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->FlushCachedGnssLocations());
469 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] FlushCachedGnssLocations001 end");
470 }
471
472 /*
473 * @tc.name: SendCommand001
474 * @tc.desc: Test send
475 * @tc.type: FUNC
476 */
477 HWTEST_F(GnssAbilityTest, SendCommand001, TestSize.Level1)
478 {
479 GTEST_LOG_(INFO)
480 << "GnssAbilityTest, SendCommand001, TestSize.Level1";
481 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SendCommand001 begin");
482 /*
483 * @tc.steps: step1. build location command
484 */
485 std::unique_ptr<LocationCommand> locationCommand = std::make_unique<LocationCommand>();
486 locationCommand->scenario = 1;
487 locationCommand->command = true;
488
489 /*
490 * @tc.steps: step2. test send command.
491 * @tc.expected: current function is empty, nothing happens
492 */
493 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendCommand(locationCommand));
494 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] SendCommand001 end");
495 }
496
497 /*
498 * @tc.name: AddFence001
499 * @tc.desc: Test add fence
500 * @tc.type: FUNC
501 */
502 HWTEST_F(GnssAbilityTest, AddFence001, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO)
505 << "GnssAbilityTest, AddFence001, TestSize.Level1";
506 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AddFence001 begin");
507 /*
508 * @tc.steps: step1. build geo fence request
509 */
510 std::unique_ptr<GeofenceRequest> request = std::make_unique<GeofenceRequest>();
511 request->scenario = 2;
512 request->geofence.latitude = 35.1;
513 request->geofence.longitude = 40.2;
514 request->geofence.radius = 2.2;
515 request->geofence.expiration = 12.2;
516
517 /*
518 * @tc.steps: step2. test add fence
519 * @tc.expected: no exception happens
520 */
521 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->AddFence(request));
522 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AddFence001 end");
523 }
524
525 /*
526 * @tc.name: RemoveFence001
527 * @tc.desc: Test add fence
528 * @tc.type: FUNC
529 */
530 HWTEST_F(GnssAbilityTest, RemoveFence001, TestSize.Level1)
531 {
532 GTEST_LOG_(INFO)
533 << "GnssAbilityTest, RemoveFence001, TestSize.Level1";
534 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RemoveFence001 begin");
535 /*
536 * @tc.steps: step1. build geo fence request
537 */
538 std::unique_ptr<GeofenceRequest> request = std::make_unique<GeofenceRequest>();
539 request->scenario = 2;
540 request->geofence.latitude = 35.1;
541 request->geofence.longitude = 40.2;
542 request->geofence.radius = 2.2;
543 request->geofence.expiration = 12.2;
544
545 /*
546 * @tc.steps: step2. test remove fence
547 * @tc.expected: no exception happens
548 */
549 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->RemoveFence(request));
550 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] RemoveFence001 end");
551 }
552
553 HWTEST_F(GnssAbilityTest, GnssLocationMock001, TestSize.Level1)
554 {
555 GTEST_LOG_(INFO)
556 << "GnssAbilityTest, GnssLocationMock001, TestSize.Level1";
557 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssLocationMock001 begin");
558 int timeInterval = 0;
559 std::vector<std::shared_ptr<Location>> locations;
560 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->EnableMock());
561 EXPECT_EQ(true, ability_->IsMockEnabled());
562 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetMocked(timeInterval, locations));
563
564 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->DisableMock());
565 EXPECT_EQ(false, ability_->IsMockEnabled());
566 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->SetMocked(timeInterval, locations));
567 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssLocationMock001 begin");
568 }
569
570 HWTEST_F(GnssAbilityTest, GnssOnStartAndOnStop001, TestSize.Level1)
571 {
572 GTEST_LOG_(INFO)
573 << "GnssAbilityTest, GnssOnStartAndOnStop001, TestSize.Level1";
574 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssOnStartAndOnStop001 begin");
575 ability_->OnStart(); // start ability
576 EXPECT_EQ(ServiceRunningState::STATE_RUNNING, ability_->QueryServiceState());
577 ability_->OnStart(); // start ability again
578 EXPECT_EQ(ServiceRunningState::STATE_RUNNING, ability_->QueryServiceState());
579
580 ability_->OnStop(); // stop ability
581 EXPECT_EQ(ServiceRunningState::STATE_NOT_START, ability_->QueryServiceState());
582 ability_->OnStart(); // restart ability
583 EXPECT_EQ(ServiceRunningState::STATE_RUNNING, ability_->QueryServiceState());
584 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssOnStartAndOnStop001 end");
585 }
586
587 HWTEST_F(GnssAbilityTest, GnssDump001, TestSize.Level1)
588 {
589 GTEST_LOG_(INFO)
590 << "GnssAbilityTest, GnssDump001, TestSize.Level1";
591 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssDump001 begin");
592 int32_t fd = 0;
593 std::vector<std::u16string> args;
594 std::u16string arg1 = Str8ToStr16("arg1");
595 args.emplace_back(arg1);
596 std::u16string arg2 = Str8ToStr16("arg2");
597 args.emplace_back(arg2);
598 std::u16string arg3 = Str8ToStr16("arg3");
599 args.emplace_back(arg3);
600 std::u16string arg4 = Str8ToStr16("arg4");
601 args.emplace_back(arg4);
602 EXPECT_EQ(ERR_OK, ability_->Dump(fd, args));
603
604 std::vector<std::u16string> emptyArgs;
605 EXPECT_EQ(ERR_OK, ability_->Dump(fd, emptyArgs));
606
607 std::vector<std::u16string> helpArgs;
608 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
609 helpArgs.emplace_back(helpArg1);
610 EXPECT_EQ(ERR_OK, ability_->Dump(fd, helpArgs));
611 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssDump001 end");
612 }
613
614 HWTEST_F(GnssAbilityTest, GnssSendReportMockLocationEvent001, TestSize.Level1)
615 {
616 GTEST_LOG_(INFO)
617 << "GnssAbilityTest, GnssSendReportMockLocationEvent001, TestSize.Level1";
618 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssSendReportMockLocationEvent001 begin");
619 ability_->SendReportMockLocationEvent(); // clear location mock
620
621 int timeInterval = 0;
622 std::vector<std::shared_ptr<Location>> locations;
623 Parcel parcel;
624 parcel.WriteDouble(10.6); // latitude
625 parcel.WriteDouble(10.5); // longitude
626 parcel.WriteDouble(10.4); // altitude
627 parcel.WriteDouble(1.0); // accuracy
628 parcel.WriteDouble(5.0); // speed
629 parcel.WriteDouble(10); // direction
630 parcel.WriteInt64(1611000000); // timestamp
631 parcel.WriteInt64(1611000000); // time since boot
632 parcel.WriteString16(u"additions"); // additions
633 parcel.WriteInt64(1); // additionSize
634 parcel.WriteBool(true); // isFromMock is true
635 parcel.WriteInt32(1); // source type
636 parcel.WriteInt32(0); // floor no.
637 parcel.WriteDouble(1000.0); // floor acc
638 locations.push_back(Location::UnmarshallingShared(parcel));
639 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
640 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
641 sleep(2);
642 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssSendReportMockLocationEvent001 end");
643 }
644
645 HWTEST_F(GnssAbilityTest, GnssSendReportMockLocationEvent002, TestSize.Level1)
646 {
647 GTEST_LOG_(INFO)
648 << "GnssAbilityTest, GnssSendReportMockLocationEvent002, TestSize.Level1";
649 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssSendReportMockLocationEvent002 begin");
650 ability_->SendReportMockLocationEvent(); // clear location mock
651
652 int timeInterval = 0;
653 std::vector<std::shared_ptr<Location>> locations;
654 Parcel parcel;
655 parcel.WriteDouble(10.6); // latitude
656 parcel.WriteDouble(10.5); // longitude
657 parcel.WriteDouble(10.4); // altitude
658 parcel.WriteDouble(1.0); // accuracy
659 parcel.WriteDouble(5.0); // speed
660 parcel.WriteDouble(10); // direction
661 parcel.WriteInt64(1611000000); // timestamp
662 parcel.WriteInt64(1611000000); // time since boot
663 parcel.WriteString16(u"additions"); // additions
664 parcel.WriteInt64(1); // additionSize
665 parcel.WriteBool(false); // isFromMock is false
666 parcel.WriteInt32(1); // source type
667 parcel.WriteInt32(0); // floor no.
668 parcel.WriteDouble(1000.0); // floor acc
669 locations.push_back(Location::UnmarshallingShared(parcel));
670 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
671 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
672 sleep(2);
673 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssSendReportMockLocationEvent002 end");
674 }
675
676 HWTEST_F(GnssAbilityTest, AddFenceAndRemoveFenceTest001, TestSize.Level1)
677 {
678 GTEST_LOG_(INFO)
679 << "GnssAbilityTest, AddFenceAndRemoveFenceTest001, TestSize.Level1";
680 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AddFenceAndRemoveFenceTest001 begin");
681 std::unique_ptr<GeofenceRequest> fence = std::make_unique<GeofenceRequest>();
682 ability_->AddFence(fence);
683 ability_->RemoveFence(fence);
684 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AddFenceAndRemoveFenceTest001 end");
685 }
686
687 HWTEST_F(GnssAbilityTest, GnssAbilityReportSv001, TestSize.Level1)
688 {
689 GTEST_LOG_(INFO)
690 << "GnssAbilityTest, GnssAbilityReportSv001, TestSize.Level1";
691 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssAbilityReportSv001 begin");
692 std::unique_ptr<SatelliteStatus> status = std::make_unique<SatelliteStatus>();
693 MessageParcel parcel;
694 int sateNum = 2;
695 parcel.WriteInt64(2); // satellitesNumber
696 for (int i = 0; i < sateNum; i++) {
697 parcel.WriteInt64(i); // satelliteId
698 parcel.WriteDouble(i + 1.0); // carrierToNoiseDensity
699 parcel.WriteDouble(i + 2.0); // altitude
700 parcel.WriteDouble(i + 3.0); // azimuth
701 parcel.WriteDouble(i + 4.0); // carrierFrequency
702 }
703 status->ReadFromParcel(parcel);
704 ability_->ReportSv(status);
705 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssAbilityReportSv001 end");
706 }
707
708 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestSetUpAgnssDataLink001, TestSize.Level1)
709 {
710 GTEST_LOG_(INFO)
711 << "GnssAbilityTest, AGnssEventCallbackRequestSetUpAgnssDataLink001, TestSize.Level1";
712 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestSetUpAgnssDataLink001 begin");
713 sptr<IAGnssCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
714 EXPECT_NE(nullptr, agnssCallback);
715 AGnssDataLinkRequest request;
716 request.agnssType = HDI::Location::Agnss::V1_0::AGNSS_TYPE_SUPL;
717 request.setUpType = HDI::Location::Agnss::V1_0::ESTABLISH_DATA_CONNECTION;
718 EXPECT_EQ(ERR_OK, agnssCallback->RequestSetUpAgnssDataLink(request));
719 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestSetUpAgnssDataLink001 end");
720 }
721
722 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestSubscriberSetId001, TestSize.Level1)
723 {
724 GTEST_LOG_(INFO)
725 << "GnssAbilityTest, AGnssEventCallbackRequestSubscriberSetId001, TestSize.Level1";
726 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestSubscriberSetId001 begin");
727 sptr<IAGnssCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
728 EXPECT_NE(nullptr, agnssCallback);
729 SubscriberSetIdType type = HDI::Location::Agnss::V1_0::SETID_TYPE_IMSI;
730 EXPECT_EQ(ERR_OK, agnssCallback->RequestSubscriberSetId(type));
731 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestSubscriberSetId001 end");
732 }
733
734 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo001, TestSize.Level1)
735 {
736 GTEST_LOG_(INFO)
737 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo001, TestSize.Level1";
738 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo001 begin");
739 sptr<IAGnssCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
740 EXPECT_CALL(MockICellularDataManager::GetInstance(), GetDefaultCellularDataSlotId).WillRepeatedly(Return(-1));
741 EXPECT_NE(nullptr, agnssCallback);
742 EXPECT_EQ(ERR_OK, agnssCallback->RequestAgnssRefInfo());
743 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo001 end");
744 }
745
746 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo002, TestSize.Level1)
747 {
748 GTEST_LOG_(INFO)
749 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo002, TestSize.Level1";
750 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo002 begin");
751 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
752 EXPECT_NE(nullptr, agnssCallback);
753 AGnssRefInfo refInfo;
754 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
755 sptr<Telephony::GsmCellInformation> gsmCellInformation = new Telephony::GsmCellInformation();
756 gsmCellInformation->Init(0, 0, 0);
757 agnssCallback->JudgmentDataGsm(refInfo, gsmCellInformation);
758 EXPECT_EQ(HDI::Location::Agnss::V1_0::CELLID_TYPE_GSM, refInfo.cellId.type);
759 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo002 end");
760 }
761
762 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo003, TestSize.Level1)
763 {
764 GTEST_LOG_(INFO)
765 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo003, TestSize.Level1";
766 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo003 begin");
767 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
768 EXPECT_NE(nullptr, agnssCallback);
769 AGnssRefInfo refInfo;
770 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
771 sptr<Telephony::GsmCellInformation> gsmCellInformation = nullptr;
772 agnssCallback->JudgmentDataGsm(refInfo, gsmCellInformation);
773 EXPECT_NE(HDI::Location::Agnss::V1_0::CELLID_TYPE_GSM, refInfo.cellId.type);
774 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo003 begin");
775 }
776
777 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo004, TestSize.Level1)
778 {
779 GTEST_LOG_(INFO)
780 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo004, TestSize.Level1";
781 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo004 begin");
782 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
783 EXPECT_NE(nullptr, agnssCallback);
784 AGnssRefInfo refInfo;
785 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
786 sptr<Telephony::LteCellInformation> lteCellInformation = new Telephony::LteCellInformation();
787 lteCellInformation->Init(0, 0, 0);
788 agnssCallback->JudgmentDataLte(refInfo, lteCellInformation);
789 EXPECT_EQ(HDI::Location::Agnss::V1_0::CELLID_TYPE_LTE, refInfo.cellId.type);
790 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo004 begin");
791 }
792
793 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo005, TestSize.Level1)
794 {
795 GTEST_LOG_(INFO)
796 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo005, TestSize.Level1";
797 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo005 begin");
798 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
799 EXPECT_NE(nullptr, agnssCallback);
800 AGnssRefInfo refInfo;
801 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
802 sptr<Telephony::LteCellInformation> lteCellInformation = nullptr;
803 agnssCallback->JudgmentDataLte(refInfo, lteCellInformation);
804 EXPECT_NE(HDI::Location::Agnss::V1_0::CELLID_TYPE_LTE, refInfo.cellId.type);
805 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo005 begin");
806 }
807
808 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo006, TestSize.Level1)
809 {
810 GTEST_LOG_(INFO)
811 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo006, TestSize.Level1";
812 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo006 begin");
813 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
814 EXPECT_NE(nullptr, agnssCallback);
815 AGnssRefInfo refInfo;
816 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
817 sptr<Telephony::WcdmaCellInformation> umtsCellInformation = new Telephony::WcdmaCellInformation();
818 umtsCellInformation->Init(0, 0, 0);
819 agnssCallback->JudgmentDataUmts(refInfo, umtsCellInformation);
820 EXPECT_EQ(HDI::Location::Agnss::V1_0::CELLID_TYPE_UMTS, refInfo.cellId.type);
821 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo006 begin");
822 }
823
824 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo007, TestSize.Level1)
825 {
826 GTEST_LOG_(INFO)
827 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo007, TestSize.Level1";
828 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo007 begin");
829 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
830 EXPECT_NE(nullptr, agnssCallback);
831 AGnssRefInfo refInfo;
832 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
833 sptr<Telephony::WcdmaCellInformation> umtsCellInformation = nullptr;
834 agnssCallback->JudgmentDataUmts(refInfo, umtsCellInformation);
835 EXPECT_NE(HDI::Location::Agnss::V1_0::CELLID_TYPE_UMTS, refInfo.cellId.type);
836 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo007 begin");
837 }
838
839 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo008, TestSize.Level1)
840 {
841 GTEST_LOG_(INFO)
842 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo008, TestSize.Level1";
843 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo008 begin");
844 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
845 EXPECT_NE(nullptr, agnssCallback);
846 AGnssRefInfo refInfo;
847 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
848 sptr<Telephony::NrCellInformation> nrCellInformation = new Telephony::NrCellInformation();
849 nrCellInformation->Init(0, 0, 0);
850 agnssCallback->JudgmentDataNr(refInfo, nrCellInformation);
851 EXPECT_EQ(HDI::Location::Agnss::V1_0::CELLID_TYPE_NR, refInfo.cellId.type);
852 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo008 begin");
853 }
854
855 HWTEST_F(GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo009, TestSize.Level1)
856 {
857 GTEST_LOG_(INFO)
858 << "GnssAbilityTest, AGnssEventCallbackRequestAgnssRefInfo009, TestSize.Level1";
859 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo009 begin");
860 sptr<AGnssEventCallback> agnssCallback = new (std::nothrow) AGnssEventCallback();
861 EXPECT_NE(nullptr, agnssCallback);
862 AGnssRefInfo refInfo;
863 refInfo.type = HDI::Location::Agnss::V1_0::ANSS_REF_INFO_TYPE_CELLID;
864 sptr<Telephony::NrCellInformation> nrCellInformation = nullptr;
865 agnssCallback->JudgmentDataNr(refInfo, nrCellInformation);
866 EXPECT_NE(HDI::Location::Agnss::V1_0::CELLID_TYPE_NR, refInfo.cellId.type);
867 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] AGnssEventCallbackRequestAgnssRefInfo009 begin");
868 }
869
870 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportLocation001, TestSize.Level1)
871 {
872 GTEST_LOG_(INFO)
873 << "GnssAbilityTest, GnssEventCallbackReportLocation001, TestSize.Level1";
874 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportLocation001 begin");
875 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
876 EXPECT_NE(nullptr, gnssCallback);
877 LocationInfo locationInfo;
878 locationInfo.latitude = 1.0;
879 locationInfo.longitude = 2.0;
880 locationInfo.altitude = 1.0;
881 locationInfo.accuracy = 1.0;
882 locationInfo.speed = 1.0;
883 locationInfo.direction= 1.0;
884 locationInfo.timeStamp = 1000000000;
885 locationInfo.timeSinceBoot = 1000000000;
886 gnssCallback->ReportLocation(locationInfo);
887 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportLocation001 end");
888 }
889
890 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportGnssWorkingStatus001, TestSize.Level1)
891 {
892 GTEST_LOG_(INFO)
893 << "GnssAbilityTest, GnssEventCallbackReportGnssWorkingStatus001, TestSize.Level1";
894 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportGnssWorkingStatus001 begin");
895 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
896 EXPECT_NE(nullptr, gnssCallback);
897 GnssWorkingStatus status = HDI::Location::Gnss::V1_0::GNSS_STATUS_NONE;
898 gnssCallback->ReportGnssWorkingStatus(status);
899 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportGnssWorkingStatus001 end");
900 }
901
902 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportNmea001, TestSize.Level1)
903 {
904 GTEST_LOG_(INFO)
905 << "GnssAbilityTest, GnssEventCallbackReportNmea001, TestSize.Level1";
906 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportNmea001 begin");
907 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
908 EXPECT_NE(nullptr, gnssCallback);
909 gnssCallback->ReportNmea(0, "nmea", 0);
910 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportNmea001 end");
911 }
912
913 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportGnssCapabilities001, TestSize.Level1)
914 {
915 GTEST_LOG_(INFO)
916 << "GnssAbilityTest, GnssEventCallbackReportGnssCapabilities001, TestSize.Level1";
917 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportGnssCapabilities001 begin");
918 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
919 EXPECT_NE(nullptr, gnssCallback);
920 GnssCapabilities capabilities = HDI::Location::Gnss::V1_0::GNSS_CAP_SUPPORT_MSB;
921 gnssCallback->ReportGnssCapabilities(capabilities);
922 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportGnssCapabilities001 end");
923 }
924
925 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportSatelliteStatusInfo002, TestSize.Level1)
926 {
927 GTEST_LOG_(INFO)
928 << "GnssAbilityTest, GnssEventCallbackReportSatelliteStatusInfo002, TestSize.Level1";
929 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportSatelliteStatusInfo002 begin");
930 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
931 EXPECT_NE(nullptr, gnssCallback);
932 SatelliteStatusInfo statusInfo;
933 statusInfo.satellitesNumber = 0;
934 statusInfo.flags =
935 HDI::Location::Gnss::V1_0::SATELLITES_STATUS_HAS_EPHEMERIS_DATA;
936 gnssCallback->ReportSatelliteStatusInfo(statusInfo);
937 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportSatelliteStatusInfo002 end");
938 }
939
940 HWTEST_F(GnssAbilityTest, GnssEventCallbackRequestGnssReferenceInfo001, TestSize.Level1)
941 {
942 GTEST_LOG_(INFO)
943 << "GnssAbilityTest, GnssEventCallbackRequestGnssReferenceInfo001, TestSize.Level1";
944 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackRequestGnssReferenceInfo001 begin");
945 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
946 EXPECT_NE(nullptr, gnssCallback);
947 GnssRefInfoType type = HDI::Location::Gnss::V1_0::GNSS_REF_INFO_TIME;
948 gnssCallback->RequestGnssReferenceInfo(type);
949 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackRequestGnssReferenceInfo001 end");
950 }
951
952 HWTEST_F(GnssAbilityTest, GnssEventCallbackRequestPredictGnssData001, TestSize.Level1)
953 {
954 GTEST_LOG_(INFO)
955 << "GnssAbilityTest, GnssEventCallbackRequestPredictGnssData001, TestSize.Level1";
956 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackRequestPredictGnssData001 begin");
957 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
958 EXPECT_NE(nullptr, gnssCallback);
959 gnssCallback->RequestPredictGnssData();
960 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackRequestPredictGnssData001 end");
961 }
962
963 HWTEST_F(GnssAbilityTest, GnssEventCallbackReportCachedLocation001, TestSize.Level1)
964 {
965 GTEST_LOG_(INFO)
966 << "GnssAbilityTest, GnssEventCallbackReportCachedLocation001, TestSize.Level1";
967 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportCachedLocation001 begin");
968 sptr<IGnssCallback> gnssCallback = new (std::nothrow) GnssEventCallback();
969 EXPECT_NE(nullptr, gnssCallback);
970 std::vector<LocationInfo> gnssLocations;
971 LocationInfo locationInfo;
972 locationInfo.latitude = 1.0;
973 locationInfo.longitude = 2.0;
974 locationInfo.altitude = 1.0;
975 locationInfo.accuracy = 1.0;
976 locationInfo.speed = 1.0;
977 locationInfo.direction= 1.0;
978 locationInfo.timeStamp = 1000000000;
979 locationInfo.timeSinceBoot = 1000000000;
980 gnssLocations.push_back(locationInfo);
981 gnssCallback->ReportCachedLocation(gnssLocations);
982 LBSLOGI(GNSS_TEST, "[GnssAbilityTest] GnssEventCallbackReportCachedLocation001 end");
983 }
984
985 } // namespace Location
986 } // namespace OHOS