1 /*
2 * Copyright (c) 2021-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 <iostream>
17 #include <osal_mem.h>
18 #include "hdf_sbuf.h"
19 #include <cmath>
20 #include <cstdio>
21 #include <unistd.h>
22 #include <gtest/gtest.h>
23 #include "idevmgr_hdi.h"
24 #include <securec.h>
25 #include "hdf_base.h"
26 #include "hdf_log.h"
27 #include "osal_time.h"
28 #include "v1_0/igeofence_interface.h"
29 #include "geofence_interface_impl.h"
30 #include "geofence_callback_impl.h"
31
32 using namespace OHOS::HDI::Location::Geofence::V1_0;
33 using namespace std;
34 using namespace testing::ext;
35
36 namespace {
37 sptr<IGeofenceInterface> g_igeofenceHci = nullptr;
38 } // namespace
39
40 class LocationGeofenceAdditionalTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47
ReportGeofenceAvailability(bool isAvailable)48 int32_t GeofenceCallbackImpl::ReportGeofenceAvailability(bool isAvailable)
49 {
50 (void)isAvailable;
51 return HDF_SUCCESS;
52 }
53
ReportGeofenceEvent(int32_t fenceIndex,const LocationInfo & location,GeofenceEvent event,int64_t timestamp)54 int32_t GeofenceCallbackImpl::ReportGeofenceEvent(int32_t fenceIndex, const LocationInfo &location, GeofenceEvent event,
55 int64_t timestamp)
56 {
57 (void)fenceIndex;
58 (void)location;
59 (void)event;
60 (void)timestamp;
61 return HDF_SUCCESS;
62 }
63
ReportGeofenceOperateResult(int32_t fenceIndex,GeofenceOperateType type,GeofenceOperateResult result)64 int32_t GeofenceCallbackImpl::ReportGeofenceOperateResult(int32_t fenceIndex, GeofenceOperateType type,
65 GeofenceOperateResult result)
66 {
67 (void)fenceIndex;
68 (void)type;
69 (void)result;
70 return HDF_SUCCESS;
71 }
72
SetUpTestCase()73 void LocationGeofenceAdditionalTest::SetUpTestCase()
74 {
75 auto devmgr = HDI::DeviceManager::V1_0::IDeviceManager::Get();
76 if (devmgr == nullptr) {
77 printf("fail to get devmgr.\n");
78 return;
79 }
80 if (devmgr->LoadDevice("gnss_interface_service") != 0) {
81 printf("Load gnss service failed!\n");
82 return;
83 }
84 if (devmgr->LoadDevice("agnss_interface_service") != 0) {
85 printf("Load agnss service failed!\n");
86 return;
87 }
88 if (devmgr->LoadDevice("geofence_interface_service") != 0) {
89 printf("Load geofence service failed!\n");
90 return;
91 }
92 g_igeofenceHci = IGeofenceInterface::Get();
93 }
94
TearDownTestCase()95 void LocationGeofenceAdditionalTest::TearDownTestCase()
96 {
97 auto devmgr = HDI::DeviceManager::V1_0::IDeviceManager::Get();
98 if (devmgr == nullptr) {
99 printf("fail to get devmgr.\n");
100 return;
101 }
102 if (devmgr->UnloadDevice("gnss_interface_service") != 0) {
103 printf("Load gnss service failed!\n");
104 return;
105 }
106 if (devmgr->UnloadDevice("agnss_interface_service") != 0) {
107 printf("Load agnss service failed!\n");
108 return;
109 }
110 if (devmgr->UnloadDevice("geofence_interface_service") != 0) {
111 printf("Load geofence service failed!\n");
112 return;
113 }
114 }
115
SetUp()116 void LocationGeofenceAdditionalTest::SetUp() {}
117
TearDown()118 void LocationGeofenceAdditionalTest::TearDown() {}
119
120 /**
121 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0200
122 * @tc.name : testAddGnssGeofence001
123 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
124 */
125 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence001, Function | MediumTest | Level1)
126 {
127 GeofenceInfo fence;
128 fence.fenceIndex = 1;
129 fence.latitude = 1.00;
130 fence.longitude = 1.00;
131 fence.radius = 1.00;
132 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
133 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
134 EXPECT_EQ(HDF_SUCCESS, ret);
135 }
136
137 /**
138 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0300
139 * @tc.name : testAddGnssGeofence002
140 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN 100times.
141 */
142 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence002, Function | MediumTest | Level1)
143 {
144 int32_t ret = 0;
145 GeofenceInfo fence;
146 fence.fenceIndex = 1;
147 fence.latitude = 1.00;
148 fence.longitude = 1.00;
149 fence.radius = 1.00;
150 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
151 for (int i = 0; i < 100; i++) {
152 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
153 EXPECT_EQ(HDF_SUCCESS, ret);
154 }
155 }
156
157 /**
158 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0400
159 * @tc.name : testAddGnssGeofence003
160 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
161 */
162 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence003, Function | MediumTest | Level1)
163 {
164 GeofenceInfo fence;
165 fence.fenceIndex = 1;
166 fence.latitude = 180.00;
167 fence.longitude = 1.00;
168 fence.radius = 1.00;
169 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
170 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
171 EXPECT_EQ(HDF_SUCCESS, ret);
172 }
173
174 /**
175 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0500
176 * @tc.name : testAddGnssGeofence004
177 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
178 */
179 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence004, Function | MediumTest | Level1)
180 {
181 GeofenceInfo fence;
182 fence.fenceIndex = 1;
183 fence.latitude = 180.00;
184 fence.longitude = 1.00;
185 fence.radius = 1.00;
186 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
187 int32_t ret = 0;
188 for (int i = 0; i < 100; i++) {
189 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
190 EXPECT_EQ(HDF_SUCCESS, ret);
191 }
192 }
193
194 /**
195 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0600
196 * @tc.name : testAddGnssGeofence005
197 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
198 */
199 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence005, Function | MediumTest | Level1)
200 {
201 GeofenceInfo fence;
202 fence.fenceIndex = 1;
203 fence.latitude = 1.00;
204 fence.longitude = 180.00;
205 fence.radius = 1.00;
206 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
207 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
208 EXPECT_EQ(HDF_SUCCESS, ret);
209 }
210
211 /**
212 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0700
213 * @tc.name : testAddGnssGeofence006
214 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
215 */
216 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence006, Function | MediumTest | Level1)
217 {
218 GeofenceInfo fence;
219 fence.fenceIndex = 1;
220 fence.latitude = 1.00;
221 fence.longitude = 180.00;
222 fence.radius = 1.00;
223 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
224 int32_t ret = 0;
225 for (int i = 0; i < 100; i++) {
226 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
227 EXPECT_EQ(HDF_SUCCESS, ret);
228 }
229 }
230
231 /**
232 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0800
233 * @tc.name : testAddGnssGeofence007
234 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
235 */
236 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence007, Function | MediumTest | Level1)
237 {
238 GeofenceInfo fence;
239 fence.fenceIndex = 1;
240 fence.latitude = 180.00;
241 fence.longitude = 180.00;
242 fence.radius = 1.00;
243 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
244 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
245 EXPECT_EQ(HDF_SUCCESS, ret);
246 }
247
248 /**
249 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_0900
250 * @tc.name : testAddGnssGeofence008
251 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
252 */
253 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence008, Function | MediumTest | Level1)
254 {
255 GeofenceInfo fence;
256 fence.fenceIndex = 1;
257 fence.latitude = 180.00;
258 fence.longitude = 180.00;
259 fence.radius = 1.00;
260 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
261 int32_t ret = 0;
262 for (int i = 0; i < 100; i++) {
263 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
264 EXPECT_EQ(HDF_SUCCESS, ret);
265 }
266 }
267
268 /**
269 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1000
270 * @tc.name : testAddGnssGeofence009
271 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_UNCERTAIN.
272 */
273 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence009, Function | MediumTest | Level1)
274 {
275 GeofenceInfo fence;
276 fence.fenceIndex = 1;
277 fence.latitude = 180.00;
278 fence.longitude = 180.00;
279 fence.radius = 180.00;
280 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_UNCERTAIN;
281 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
282 EXPECT_EQ(HDF_SUCCESS, ret);
283 }
284
285 /**
286 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1100
287 * @tc.name : testAddGnssGeofence010
288 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
289 */
290 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence010, Function | MediumTest | Level1)
291 {
292 GeofenceInfo fence;
293 fence.fenceIndex = 1;
294 fence.latitude = 1.00;
295 fence.longitude = 1.00;
296 fence.radius = 1.00;
297 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
298 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
299 EXPECT_EQ(HDF_SUCCESS, ret);
300 }
301
302 /**
303 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1200
304 * @tc.name : testAddGnssGeofence011
305 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED 100times.
306 */
307 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence011, Function | MediumTest | Level1)
308 {
309 int32_t ret = 0;
310 GeofenceInfo fence;
311 fence.fenceIndex = 1;
312 fence.latitude = 1.00;
313 fence.longitude = 1.00;
314 fence.radius = 1.00;
315 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
316 for (int i = 0; i < 100; i++) {
317 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
318 EXPECT_EQ(HDF_SUCCESS, ret);
319 }
320 }
321
322 /**
323 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1300
324 * @tc.name : testAddGnssGeofence012
325 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
326 */
327 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence012, Function | MediumTest | Level1)
328 {
329 GeofenceInfo fence;
330 fence.fenceIndex = 1;
331 fence.latitude = 180.00;
332 fence.longitude = 1.00;
333 fence.radius = 1.00;
334 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
335 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
336 EXPECT_EQ(HDF_SUCCESS, ret);
337 }
338
339 /**
340 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1400
341 * @tc.name : testAddGnssGeofence013
342 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
343 */
344 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence013, Function | MediumTest | Level1)
345 {
346 GeofenceInfo fence;
347 fence.fenceIndex = 1;
348 fence.latitude = 180.00;
349 fence.longitude = 1.00;
350 fence.radius = 1.00;
351 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
352 int32_t ret = 0;
353 for (int i = 0; i < 100; i++) {
354 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
355 EXPECT_EQ(HDF_SUCCESS, ret);
356 }
357 }
358
359 /**
360 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1500
361 * @tc.name : testAddGnssGeofence014
362 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
363 */
364 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence014, Function | MediumTest | Level1)
365 {
366 GeofenceInfo fence;
367 fence.fenceIndex = 1;
368 fence.latitude = 1.00;
369 fence.longitude = 180.00;
370 fence.radius = 1.00;
371 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
372 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
373 EXPECT_EQ(HDF_SUCCESS, ret);
374 }
375
376 /**
377 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1600
378 * @tc.name : testAddGnssGeofence015
379 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
380 */
381 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence015, Function | MediumTest | Level1)
382 {
383 GeofenceInfo fence;
384 fence.fenceIndex = 1;
385 fence.latitude = 1.00;
386 fence.longitude = 180.00;
387 fence.radius = 1.00;
388 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
389 int32_t ret = 0;
390 for (int i = 0; i < 100; i++) {
391 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
392 EXPECT_EQ(HDF_SUCCESS, ret);
393 }
394 }
395
396 /**
397 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1700
398 * @tc.name : testAddGnssGeofence016
399 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
400 */
401 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence016, Function | MediumTest | Level1)
402 {
403 GeofenceInfo fence;
404 fence.fenceIndex = 1;
405 fence.latitude = 180.00;
406 fence.longitude = 180.00;
407 fence.radius = 1.00;
408 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
409 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
410 EXPECT_EQ(HDF_SUCCESS, ret);
411 }
412
413 /**
414 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1800
415 * @tc.name : testAddGnssGeofence017
416 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
417 */
418 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence017, Function | MediumTest | Level1)
419 {
420 GeofenceInfo fence;
421 fence.fenceIndex = 1;
422 fence.latitude = 180.00;
423 fence.longitude = 180.00;
424 fence.radius = 1.00;
425 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
426 int32_t ret = 0;
427 for (int i = 0; i < 100; i++) {
428 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
429 EXPECT_EQ(HDF_SUCCESS, ret);
430 }
431 }
432
433 /**
434 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_1900
435 * @tc.name : testAddGnssGeofence018
436 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_ENTERED.
437 */
438 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence018, Function | MediumTest | Level1)
439 {
440 GeofenceInfo fence;
441 fence.fenceIndex = 1;
442 fence.latitude = 180.00;
443 fence.longitude = 180.00;
444 fence.radius = 180.00;
445 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_ENTERED;
446 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
447 EXPECT_EQ(HDF_SUCCESS, ret);
448 }
449
450 /**
451 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2000
452 * @tc.name : testAddGnssGeofence019
453 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
454 */
455 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence019, Function | MediumTest | Level1)
456 {
457 GeofenceInfo fence;
458 fence.fenceIndex = 1;
459 fence.latitude = 1.00;
460 fence.longitude = 1.00;
461 fence.radius = 1.00;
462 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
463 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
464 EXPECT_EQ(HDF_SUCCESS, ret);
465 }
466
467 /**
468 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2100
469 * @tc.name : testAddGnssGeofence020
470 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED 100times.
471 */
472 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence020, Function | MediumTest | Level1)
473 {
474 int32_t ret = 0;
475 GeofenceInfo fence;
476 fence.fenceIndex = 1;
477 fence.latitude = 1.00;
478 fence.longitude = 1.00;
479 fence.radius = 1.00;
480 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
481 for (int i = 0; i < 100; i++) {
482 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
483 EXPECT_EQ(HDF_SUCCESS, ret);
484 }
485 }
486
487 /**
488 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2200
489 * @tc.name : testAddGnssGeofence021
490 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
491 */
492 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence021, Function | MediumTest | Level1)
493 {
494 GeofenceInfo fence;
495 fence.fenceIndex = 1;
496 fence.latitude = 180.00;
497 fence.longitude = 1.00;
498 fence.radius = 1.00;
499 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
500 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
501 EXPECT_EQ(HDF_SUCCESS, ret);
502 }
503
504 /**
505 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2300
506 * @tc.name : testAddGnssGeofence022
507 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
508 */
509 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence022, Function | MediumTest | Level1)
510 {
511 GeofenceInfo fence;
512 fence.fenceIndex = 1;
513 fence.latitude = 180.00;
514 fence.longitude = 1.00;
515 fence.radius = 1.00;
516 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
517 int32_t ret = 0;
518 for (int i = 0; i < 100; i++) {
519 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
520 EXPECT_EQ(HDF_SUCCESS, ret);
521 }
522 }
523
524 /**
525 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2400
526 * @tc.name : testAddGnssGeofence023
527 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
528 */
529 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence023, Function | MediumTest | Level1)
530 {
531 GeofenceInfo fence;
532 fence.fenceIndex = 1;
533 fence.latitude = 1.00;
534 fence.longitude = 180.00;
535 fence.radius = 1.00;
536 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
537 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
538 EXPECT_EQ(HDF_SUCCESS, ret);
539 }
540
541 /**
542 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2500
543 * @tc.name : testAddGnssGeofence024
544 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
545 */
546 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence024, Function | MediumTest | Level1)
547 {
548 GeofenceInfo fence;
549 fence.fenceIndex = 1;
550 fence.latitude = 1.00;
551 fence.longitude = 180.00;
552 fence.radius = 1.00;
553 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
554 int32_t ret = 0;
555 for (int i = 0; i < 100; i++) {
556 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
557 EXPECT_EQ(HDF_SUCCESS, ret);
558 }
559 }
560
561 /**
562 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2600
563 * @tc.name : testAddGnssGeofence025
564 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
565 */
566 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence025, Function | MediumTest | Level1)
567 {
568 GeofenceInfo fence;
569 fence.fenceIndex = 1;
570 fence.latitude = 180.00;
571 fence.longitude = 180.00;
572 fence.radius = 1.00;
573 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
574 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
575 EXPECT_EQ(HDF_SUCCESS, ret);
576 }
577
578 /**
579 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2700
580 * @tc.name : testAddGnssGeofence026
581 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
582 */
583 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence026, Function | MediumTest | Level1)
584 {
585 GeofenceInfo fence;
586 fence.fenceIndex = 1;
587 fence.latitude = 180.00;
588 fence.longitude = 180.00;
589 fence.radius = 1.00;
590 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
591 int32_t ret = 0;
592 for (int i = 0; i < 100; i++) {
593 ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
594 EXPECT_EQ(HDF_SUCCESS, ret);
595 }
596 }
597
598 /**
599 * @tc.number: SUB_Location_Geofence_AddGnssGeofence_2800
600 * @tc.name : testAddGnssGeofence027
601 * @tc.desc : Call function AddGnssGeofence with GeofenceEvent as GEOFENCE_EVENT_EXITED.
602 */
603 HWTEST_F(LocationGeofenceAdditionalTest, testAddGnssGeofence027, Function | MediumTest | Level1)
604 {
605 GeofenceInfo fence;
606 fence.fenceIndex = 1;
607 fence.latitude = 180.00;
608 fence.longitude = 180.00;
609 fence.radius = 180.00;
610 GeofenceEvent geoevent = GeofenceEvent::GEOFENCE_EVENT_EXITED;
611 int32_t ret = g_igeofenceHci->AddGnssGeofence(fence, geoevent);
612 EXPECT_EQ(HDF_SUCCESS, ret);
613 }
614
615 /**
616 * @tc.number: SUB_Location_Geofence_DeleteGnssGeofence_0200
617 * @tc.name : testDeleteGnssGeofence001
618 * @tc.desc : Call function DeleteGnssGeofence with fenceIndex as 5 100times.
619 */
620 HWTEST_F(LocationGeofenceAdditionalTest, testDeleteGnssGeofence001, Function | MediumTest | Level1)
621 {
622 int fenceIndex = 5;
623 int32_t ret = 0;
624 for (int i = 0; i < 100; i++) {
625 ret = g_igeofenceHci->DeleteGnssGeofence(fenceIndex);
626 EXPECT_EQ(HDF_SUCCESS, ret);
627 }
628 }
629
630 /**
631 * @tc.number: SUB_Location_Geofence_DeleteGnssGeofence_0300
632 * @tc.name : testDeleteGnssGeofence002
633 * @tc.desc : Call function DeleteGnssGeofence with fenceIndex as 0.
634 */
635 HWTEST_F(LocationGeofenceAdditionalTest, testDeleteGnssGeofence002, Function | MediumTest | Level1)
636 {
637 int fenceIndex = 0;
638 int32_t ret = g_igeofenceHci->DeleteGnssGeofence(fenceIndex);
639 EXPECT_EQ(HDF_SUCCESS, ret);
640 }
641
642 /**
643 * @tc.number: SUB_Location_Geofence_SetGeofenceCallback_0200
644 * @tc.name : testSetGeofenceCallback001
645 * @tc.desc : Call function SetGeofenceCallback 100times.
646 */
647 HWTEST_F(LocationGeofenceAdditionalTest, testSetGeofenceCallback001, Function | MediumTest | Level1)
648 {
649 int32_t ret = 0;
650 sptr<IGeofenceCallback> geo_callback = new (std::nothrow) GeofenceCallbackImpl();
651 if (geo_callback == nullptr) {
652 ASSERT_NE(nullptr, geo_callback);
653 return;
654 }
655 for (int i = 0; i < 100; i++) {
656 ret = g_igeofenceHci->SetGeofenceCallback(geo_callback);
657 EXPECT_EQ(HDF_SUCCESS, ret);
658 }
659 }