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