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 "report_manager_test.h"
17
18 #include "accesstoken_kit.h"
19 #include "message_parcel.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22
23 #include "i_locator_callback.h"
24 #include "location.h"
25 #include "locator.h"
26 #define private public
27 #include "locator_ability.h"
28 #include "request.h"
29 #undef private
30 #include "locator_callback_napi.h"
31 #include "locator_callback_proxy.h"
32 #include "request_manager.h"
33 #include "permission_manager.h"
34
35 using namespace testing::ext;
36 namespace OHOS {
37 namespace Location {
38 const int32_t LOCATION_PERM_NUM = 5;
39 const std::string UNKNOWN_ABILITY = "unknown_ability";
SetUp()40 void ReportManagerTest::SetUp()
41 {
42 MockNativePermission();
43 reportManager_ = ReportManager::GetInstance();
44 EXPECT_NE(nullptr, reportManager_);
45 }
46
TearDown()47 void ReportManagerTest::TearDown()
48 {
49 reportManager_ = nullptr;
50 }
51
MockNativePermission()52 void ReportManagerTest::MockNativePermission()
53 {
54 const char *perms[] = {
55 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
56 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
57 ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
58 };
59 NativeTokenInfoParams infoInstance = {
60 .dcapsNum = 0,
61 .permsNum = LOCATION_PERM_NUM,
62 .aclsNum = 0,
63 .dcaps = nullptr,
64 .perms = perms,
65 .acls = nullptr,
66 .processName = "ReportManagerTest",
67 .aplStr = "system_basic",
68 };
69 tokenId_ = GetAccessTokenId(&infoInstance);
70 SetSelfTokenID(tokenId_);
71 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
72 }
73
MockLocation()74 std::unique_ptr<Location> ReportManagerTest::MockLocation()
75 {
76 std::unique_ptr<Location> location = std::make_unique<Location>();
77 MessageParcel parcel;
78 parcel.WriteDouble(12.0); // latitude
79 parcel.WriteDouble(13.0); // longitude
80 parcel.WriteDouble(14.0); // altitude
81 parcel.WriteDouble(1000.0); // accuracy
82 parcel.WriteDouble(10.0); // speed
83 parcel.WriteDouble(90.0); // direction
84 parcel.WriteInt64(1000000000); // timeStamp
85 parcel.WriteInt64(1000000100); // timeSinceBoot
86 parcel.WriteString16(u"additions"); // additions
87 parcel.WriteInt64(1); // additionSize
88 parcel.WriteInt32(1); // isFromMock
89 location->ReadFromParcel(parcel);
90 return location;
91 }
92
93 HWTEST_F(ReportManagerTest, ReportRemoteCallbackTest001, TestSize.Level1)
94 {
95 GTEST_LOG_(INFO)
96 << "ReportManagerTest, ReportRemoteCallbackTest001, TestSize.Level1";
97 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportRemoteCallbackTest001 begin");
98 std::unique_ptr<Location> location = std::make_unique<Location>();
99 auto locatorCallbackHostForTest =
100 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
101 sptr<ILocatorCallback> locatorCallback =
102 sptr<ILocatorCallback>(locatorCallbackHostForTest);
103 EXPECT_EQ(true, reportManager_->
104 ReportRemoteCallback(locatorCallback, ILocatorCallback::RECEIVE_LOCATION_STATUS_EVENT, 1));
105 EXPECT_EQ(true, reportManager_->
106 ReportRemoteCallback(locatorCallback, ILocatorCallback::RECEIVE_ERROR_INFO_EVENT, 1));
107 EXPECT_EQ(false, reportManager_->
108 ReportRemoteCallback(locatorCallback, ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT, 1));
109 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportRemoteCallbackTest001 end");
110 }
111
112 HWTEST_F(ReportManagerTest, ResultCheckTest001, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO)
115 << "ReportManagerTest, ResultCheckTest001, TestSize.Level1";
116 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest001 begin");
117 std::shared_ptr<Request> request = std::make_shared<Request>();
118 request->SetUid(1000);
119 request->SetPid(0);
120 request->SetTokenId(tokenId_);
121 request->SetFirstTokenId(0);
122 request->SetPackageName("ReportManagerTest");
123 auto location = MockLocation();
124
125 EXPECT_EQ(true, reportManager_->ResultCheck(location, request));
126 EXPECT_EQ(false, reportManager_->ResultCheck(nullptr, request)); // no location
127 EXPECT_EQ(false, reportManager_->ResultCheck(location, nullptr)); // no request
128 EXPECT_EQ(false, reportManager_->ResultCheck(nullptr, nullptr)); // no location & no request
129
130 auto requestConfig = std::make_unique<RequestConfig>();
131 EXPECT_NE(nullptr, requestConfig);
132 requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
133 requestConfig->SetMaxAccuracy(1000.0);
134 requestConfig->SetFixNumber(1);
135 request->SetRequestConfig(*requestConfig);
136 EXPECT_EQ(true, reportManager_->ResultCheck(location, request)); // no last location
137
138 std::unique_ptr<Location> lastLocation1 = std::make_unique<Location>(*location);
139 lastLocation1->SetLatitude(-91.0);
140 request->SetLastLocation(lastLocation1);
141 EXPECT_EQ(true, reportManager_->ResultCheck(location, request)); // no need to check
142
143 std::unique_ptr<Location> lastLocation2 = std::make_unique<Location>(*location);
144 request->SetLastLocation(lastLocation2);
145 reportManager_->ResultCheck(location, request); // time interval check failed
146
147 std::unique_ptr<Location> lastLocation3 = std::make_unique<Location>(*location);
148 lastLocation3->SetTimeSinceBoot(1000000000);
149 requestConfig->SetDistanceInterval(1.0);
150 request->SetRequestConfig(*requestConfig);
151 request->SetLastLocation(lastLocation3);
152 reportManager_->ResultCheck(location, request); // distance interval check failed
153
154 std::unique_ptr<Location> lastLocation4 = std::make_unique<Location>(*location);
155 lastLocation4->SetTimeSinceBoot(1000000000);
156 requestConfig->SetDistanceInterval(0.0);
157 requestConfig->SetMaxAccuracy(10.0);
158 request->SetRequestConfig(*requestConfig);
159 request->SetLastLocation(lastLocation4);
160 EXPECT_EQ(false, reportManager_->ResultCheck(location, request)); // acc check failed
161
162 std::unique_ptr<Location> lastLocation5 = std::make_unique<Location>(*location);
163 lastLocation5->SetTimeSinceBoot(1000000000);
164 requestConfig->SetDistanceInterval(0.0);
165 requestConfig->SetMaxAccuracy(10.0);
166 request->SetRequestConfig(*requestConfig);
167 request->SetLocatorCallBack(nullptr);
168 request->SetLastLocation(lastLocation5);
169 EXPECT_EQ(false, reportManager_->ResultCheck(location, request)); // acc check failed and null locator callback
170 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest001 end");
171 }
172
173 HWTEST_F(ReportManagerTest, ResultCheckTest002, TestSize.Level1)
174 {
175 GTEST_LOG_(INFO)
176 << "ReportManagerTest, ResultCheckTest002, TestSize.Level1";
177 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest002 begin");
178 std::shared_ptr<Request> request = std::make_shared<Request>();
179 request->SetUid(1000);
180 request->SetPid(0);
181 request->SetTokenId(tokenId_);
182 request->SetFirstTokenId(0);
183 request->SetPackageName("ReportManagerTest");
184 auto requestConfig = std::make_unique<RequestConfig>();
185 EXPECT_NE(nullptr, requestConfig);
186 requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
187 requestConfig->SetMaxAccuracy(1000.0);
188 requestConfig->SetFixNumber(1);
189 request->SetRequestConfig(*requestConfig);
190 auto location = MockLocation();
191
192 std::unique_ptr<Location> lastLocation5 = std::make_unique<Location>(*location);
193 lastLocation5->SetTimeSinceBoot(1000000000);
194 requestConfig->SetDistanceInterval(0.0);
195 requestConfig->SetMaxAccuracy(0.0);
196 request->SetRequestConfig(*requestConfig);
197 request->SetLastLocation(lastLocation5);
198 reportManager_->ResultCheck(location, request); // check pass
199 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest002 end");
200 }
201
202 HWTEST_F(ReportManagerTest, SetLastLocationTest001, TestSize.Level1)
203 {
204 GTEST_LOG_(INFO)
205 << "ReportManagerTest, SetLastLocationTest001, TestSize.Level1";
206 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] SetLastLocationTest001 begin");
207 reportManager_->GetLastLocation();
208 int64_t curTime = CommonUtils::GetCurrentTimeStamp();
209 MessageParcel parcel;
210 parcel.WriteDouble(12.0); // latitude
211 parcel.WriteDouble(13.0); // longitude
212 parcel.WriteDouble(14.0); // altitude
213 parcel.WriteDouble(1000.0); // accuracy
214 parcel.WriteDouble(10.0); // speed
215 parcel.WriteDouble(90.0); // direction
216 parcel.WriteInt64(curTime * MILLI_PER_SEC); // timeStamp
217 parcel.WriteInt64(1000000000); // timeSinceBoot
218 parcel.WriteString16(u"additions"); // additions
219 parcel.WriteInt64(1); // additionSize
220 parcel.WriteInt32(1); // isFromMock
221 std::unique_ptr<Location> location = std::make_unique<Location>();
222 location->ReadFromParcel(parcel);
223 reportManager_->UpdateCacheLocation(location, GNSS_ABILITY);
224 std::shared_ptr<Request> request = std::make_shared<Request>();
225 request->SetUid(1000);
226 request->SetPid(0);
227 request->SetTokenId(tokenId_);
228 request->SetFirstTokenId(0);
229 request->SetPackageName("ReportManagerTest");
230 EXPECT_NE(nullptr, reportManager_->GetLastLocation());
231 reportManager_->GetCacheLocation(request);
232 reportManager_->UpdateCacheLocation(location, NETWORK_ABILITY);
233 reportManager_->GetCacheLocation(request);
234 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] SetLastLocationTest001 end");
235 }
236
237 HWTEST_F(ReportManagerTest, GetPermittedLocationTest001, TestSize.Level1)
238 {
239 GTEST_LOG_(INFO)
240 << "ReportManagerTest, GetPermittedLocationTest001, TestSize.Level1";
241 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] GetPermittedLocationTest001 begin");
242 std::shared_ptr<Request> request = std::make_shared<Request>();
243 request->SetTokenId(tokenId_);
244 EXPECT_EQ(nullptr, reportManager_->GetPermittedLocation(request, nullptr));
245 MessageParcel parcel;
246 parcel.WriteDouble(12.0); // latitude
247 parcel.WriteDouble(13.0); // longitude
248 parcel.WriteDouble(14.0); // altitude
249 parcel.WriteDouble(1000.0); // accuracy
250 parcel.WriteDouble(10.0); // speed
251 parcel.WriteDouble(90.0); // direction
252 parcel.WriteInt64(1000000000); // timeStamp
253 parcel.WriteInt64(1000000000); // timeSinceBoot
254 parcel.WriteString16(u"additions"); // additions
255 parcel.WriteInt64(1); // additionSize
256 parcel.WriteInt32(1); // isFromMock
257 std::unique_ptr<Location> location = std::make_unique<Location>();
258 location->ReadFromParcel(parcel);
259 auto newLocation = reportManager_->GetPermittedLocation(request, location);
260 EXPECT_NE(nullptr, newLocation);
261 if (newLocation != nullptr) {
262 EXPECT_EQ(12.0, newLocation->GetLatitude());
263 EXPECT_EQ(13.0, newLocation->GetLongitude());
264 EXPECT_EQ(1000.0, newLocation->GetAccuracy());
265 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] GetPermittedLocationTest001 end");
266 }
267 }
268
269 HWTEST_F(ReportManagerTest, OnReportLocationTest001, TestSize.Level1)
270 {
271 GTEST_LOG_(INFO)
272 << "ReportManagerTest, OnReportLocationTest001, TestSize.Level1";
273 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest001 begin");
274 MessageParcel parcel;
275 parcel.WriteDouble(12.0); // latitude
276 parcel.WriteDouble(13.0); // longitude
277 parcel.WriteDouble(14.0); // altitude
278 parcel.WriteDouble(1000.0); // accuracy
279 parcel.WriteDouble(10.0); // speed
280 parcel.WriteDouble(90.0); // direction
281 parcel.WriteInt64(1000000000); // timeStamp
282 parcel.WriteInt64(1000000000); // timeSinceBoot
283 parcel.WriteString16(u"additions"); // additions
284 parcel.WriteInt64(1); // additionSize
285 parcel.WriteInt32(0); // isFromMock
286 std::unique_ptr<Location> location = std::make_unique<Location>();
287 location->ReadFromParcel(parcel);
288 location->SetUuid("35279");
289 reportManager_->UpdateCacheLocation(location, NETWORK_ABILITY);
290 std::list<std::shared_ptr<Request>> networkList;
291 int num = 2;
292 for (int i = 0; i < num; i++) {
293 std::shared_ptr<Request> request = std::make_shared<Request>();
294 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
295 requestConfig->SetPriority(PRIORITY_ACCURACY);
296 requestConfig->SetTimeOut(120000);
297 requestConfig->SetScenario(SCENE_DAILY_LIFE_SERVICE);
298 requestConfig->SetFixNumber(1);
299 requestConfig->SetTimeInterval(i);
300 requestConfig->SetMaxAccuracy(20.0);
301 request->SetUid(i + 1);
302 request->SetPid(i + 2);
303 request->SetPackageName("nameForTest");
304 request->SetRequestConfig(*requestConfig);
305 request->SetUuid(std::to_string(i + 35279));
306 request->SetNlpRequestType(0);
307 networkList.push_back(request);
308 }
309 auto locatorAbility = LocatorAbility::GetInstance();
310 locatorAbility->requests_->insert(make_pair(NETWORK_ABILITY, networkList));
311
312 EXPECT_EQ(true, reportManager_->OnReportLocation(location, NETWORK_ABILITY));
313 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest001 end");
314 }
315
316 HWTEST_F(ReportManagerTest, OnReportLocationTest002, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO)
319 << "ReportManagerTest, OnReportLocationTest002, TestSize.Level1";
320 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest002 begin");
321 MessageParcel parcel;
322 parcel.WriteDouble(12.0); // latitude
323 parcel.WriteDouble(13.0); // longitude
324 parcel.WriteDouble(14.0); // altitude
325 parcel.WriteDouble(1000.0); // accuracy
326 parcel.WriteDouble(10.0); // speed
327 parcel.WriteDouble(90.0); // direction
328 parcel.WriteInt64(1000000000); // timeStamp
329 parcel.WriteInt64(1000000000); // timeSinceBoot
330 parcel.WriteString16(u"additions"); // additions
331 parcel.WriteInt64(1); // additionSize
332 parcel.WriteInt32(0); // isFromMock
333 std::unique_ptr<Location> location = std::make_unique<Location>();
334 location->ReadFromParcel(parcel);
335 EXPECT_EQ(true, reportManager_->OnReportLocation(location, NETWORK_ABILITY)); // is not requesting
336 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest002 end");
337 }
338
339 HWTEST_F(ReportManagerTest, OnReportLocationTest003, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO)
342 << "ReportManagerTest, OnReportLocationTest003, TestSize.Level1";
343 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest003 begin");
344 MessageParcel parcel;
345 parcel.WriteDouble(12.0); // latitude
346 parcel.WriteDouble(13.0); // longitude
347 parcel.WriteDouble(14.0); // altitude
348 parcel.WriteDouble(1000.0); // accuracy
349 parcel.WriteDouble(10.0); // speed
350 parcel.WriteDouble(90.0); // direction
351 parcel.WriteInt64(1000000000); // timeStamp
352 parcel.WriteInt64(1000000000); // timeSinceBoot
353 parcel.WriteString16(u"additions"); // additions
354 parcel.WriteInt64(1); // additionSize
355 parcel.WriteInt32(0); // isFromMock
356 std::unique_ptr<Location> location = std::make_unique<Location>();
357 location->ReadFromParcel(parcel);
358 EXPECT_EQ(true, reportManager_->OnReportLocation(location, NETWORK_ABILITY)); // report location successfully
359 EXPECT_EQ(true,
360 reportManager_->OnReportLocation(location, NETWORK_ABILITY)); // report the same location, result check is false
361 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest003 end");
362 }
363
364 HWTEST_F(ReportManagerTest, OnReportLocationTest004, TestSize.Level1)
365 {
366 GTEST_LOG_(INFO)
367 << "ReportManagerTest, OnReportLocationTest004, TestSize.Level1";
368 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest004 begin");
369 MessageParcel parcel;
370 parcel.WriteDouble(12.0); // latitude
371 parcel.WriteDouble(13.0); // longitude
372 parcel.WriteDouble(14.0); // altitude
373 parcel.WriteDouble(10.0); // accuracy
374 parcel.WriteDouble(10.0); // speed
375 parcel.WriteDouble(90.0); // direction
376 parcel.WriteInt64(1000000000); // timeStamp
377 parcel.WriteInt64(1000000000); // timeSinceBoot
378 parcel.WriteString16(u"additions"); // additions
379 parcel.WriteInt64(1); // additionSize
380 parcel.WriteInt32(0); // isFromMock
381 std::unique_ptr<Location> location = std::make_unique<Location>();
382 std::shared_ptr<Request> request = std::make_shared<Request>();
383 location->ReadFromParcel(parcel);
384 EXPECT_EQ(true, reportManager_->OnReportLocation(location, NETWORK_ABILITY)); // will resolve deadRequests
385 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest004 end");
386 }
387
388 HWTEST_F(ReportManagerTest, UpdateRandomTest004, TestSize.Level1)
389 {
390 GTEST_LOG_(INFO)
391 << "ReportManagerTest, UpdateRandomTest004, TestSize.Level1";
392 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateRandomTest004 begin");
393 std::list<std::shared_ptr<Request>> gnssList;
394 auto locatorAbility = LocatorAbility::GetInstance();
395 locatorAbility->requests_->insert(make_pair(GNSS_ABILITY, gnssList));
396 reportManager_->UpdateRandom();
397
398 struct timespec now;
399 clock_gettime(CLOCK_REALTIME, &now);
400 reportManager_->lastUpdateTime_.tv_sec = now.tv_sec + LONG_TIME_INTERVAL +1;
401 locatorAbility->requests_->clear();
402 reportManager_->UpdateRandom();
403 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateRandomTest004 end");
404 }
405
406 HWTEST_F(ReportManagerTest, IsRequestFuseTest001, TestSize.Level1)
407 {
408 GTEST_LOG_(INFO)
409 << "ReportManagerTest, IsRequestFuseTest001, TestSize.Level1";
410 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest001 begin");
411 EXPECT_EQ(false, reportManager_->IsRequestFuse(nullptr));
412
413 std::shared_ptr<Request> request = std::make_shared<Request>();
414 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
415 requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
416 requestConfig->SetScenario(SCENE_UNSET);
417 request->SetRequestConfig(*requestConfig);
418 EXPECT_EQ(true, reportManager_->IsRequestFuse(request));
419
420 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest001 end");
421 }
422
423 HWTEST_F(ReportManagerTest, IsRequestFuseTest002, TestSize.Level1)
424 {
425 GTEST_LOG_(INFO)
426 << "ReportManagerTest, IsRequestFuseTest002, TestSize.Level1";
427 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest002 begin");
428 EXPECT_EQ(false, reportManager_->IsRequestFuse(nullptr));
429
430 std::shared_ptr<Request> request = std::make_shared<Request>();
431 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
432 requestConfig->SetPriority(PRIORITY_UNSET);
433 requestConfig->SetScenario(SCENE_UNSET);
434 request->SetRequestConfig(*requestConfig);
435 reportManager_->IsRequestFuse(request);
436
437 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest002 end");
438 }
439
440 HWTEST_F(ReportManagerTest, UpdateLocationByRequestTest001, TestSize.Level1)
441 {
442 GTEST_LOG_(INFO)
443 << "ReportManagerTest, UpdateLocationByRequestTest001, TestSize.Level1";
444 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest001 begin");
445 auto location = MockLocation();
446 reportManager_->UpdateLocationByRequest(tokenId_, tokenId_, location);
447 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest001 end");
448 }
449
450 HWTEST_F(ReportManagerTest, UpdateLocationByRequestTest002, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO)
453 << "ReportManagerTest, UpdateLocationByRequestTest002, TestSize.Level1";
454 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest002 begin");
455 std::unique_ptr<Location> location = nullptr;
456 reportManager_->UpdateLocationByRequest(tokenId_, tokenId_, location);
457 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest002 end");
458 }
459
460 HWTEST_F(ReportManagerTest, ProcessRequestForReport001, TestSize.Level1)
461 {
462 GTEST_LOG_(INFO)
463 << "ReportManagerTest, ProcessRequestForReport001, TestSize.Level1";
464 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport001 begin");
465 std::shared_ptr<Request> request;
466 auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
467 std::unique_ptr<Location> location = std::make_unique<Location>();
468 location->SetUuid("35279");
469 reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
470 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport001 end");
471 }
472
473 HWTEST_F(ReportManagerTest, ProcessRequestForReport002, TestSize.Level1)
474 {
475 GTEST_LOG_(INFO)
476 << "ReportManagerTest, ProcessRequestForReport002, TestSize.Level1";
477 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport002 begin");
478 std::shared_ptr<Request> request = std::make_shared<Request>();
479 request->SetUid(111);
480 request->SetPid(222);
481 request->SetPackageName("nameForTest");
482 request->requestConfig_ = nullptr;
483 request->SetRequesting(true);
484 request->SetUuid(std::to_string(35279));
485 request->SetNlpRequestType(0);
486 auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
487 std::unique_ptr<Location> location = std::make_unique<Location>();
488 location->SetUuid("35279");
489 reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
490 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport002 end");
491 }
492
493 HWTEST_F(ReportManagerTest, ProcessRequestForReport003, TestSize.Level1)
494 {
495 GTEST_LOG_(INFO)
496 << "ReportManagerTest, ProcessRequestForReport003, TestSize.Level1";
497 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport003 begin");
498 std::shared_ptr<Request> request = std::make_shared<Request>();
499 request->SetUid(111);
500 request->SetPid(222);
501 request->SetPackageName("nameForTest");
502 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
503 requestConfig->SetTimeInterval(1);
504 requestConfig->SetScenario(SCENE_NO_POWER);
505 request->SetRequestConfig(*requestConfig);
506 request->SetRequesting(true);
507 request->SetUuid(std::to_string(35279));
508 request->SetNlpRequestType(0);
509 auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
510 std::unique_ptr<Location> location = std::make_unique<Location>();
511 location->SetUuid("35279");
512 reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
513 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport003 end");
514 }
515
516 HWTEST_F(ReportManagerTest, ProcessRequestForReport004, TestSize.Level1)
517 {
518 GTEST_LOG_(INFO)
519 << "ReportManagerTest, ProcessRequestForReport004, TestSize.Level1";
520 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport004 begin");
521 std::shared_ptr<Request> request = std::make_shared<Request>();
522 request->SetUid(111);
523 request->SetPid(222);
524 request->SetPackageName("nameForTest");
525 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
526 requestConfig->SetTimeInterval(1);
527 request->SetRequestConfig(*requestConfig);
528 request->SetRequesting(true);
529 request->SetUuid(std::to_string(35279));
530 request->SetNlpRequestType(0);
531 auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
532 std::unique_ptr<Location> location = std::make_unique<Location>();
533 location->SetUuid("35279");
534 reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
535 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport004 end");
536 }
537
538 HWTEST_F(ReportManagerTest, WriteNetWorkReportEvent, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO)
541 << "ReportManagerTest, WriteNetWorkReportEvent, TestSize.Level1";
542 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] WriteNetWorkReportEvent begin");
543 std::shared_ptr<Request> request = std::make_shared<Request>();
544 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
545 requestConfig->SetTimeInterval(1);
546 request->SetUid(111);
547 request->SetPid(222);
548 request->SetPackageName("nameForTest");
549 request->SetRequestConfig(*requestConfig);
550 request->SetRequesting(true);
551 request->SetUuid(std::to_string(35279));
552 request->SetNlpRequestType(0);
553 std::unique_ptr<Location> location = std::make_unique<Location>();
554 location->SetUuid("35279");
555 reportManager_->WriteNetWorkReportEvent(NETWORK_ABILITY, request, location);
556 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] WriteNetWorkReportEvent end");
557 }
558
559 HWTEST_F(ReportManagerTest, ReportLocationByCallback001, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO)
562 << "ReportManagerTest, ReportLocationByCallback001, TestSize.Level1";
563 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportLocationByCallback001 begin");
564 std::shared_ptr<Request> request = std::make_shared<Request>();
565 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
566 requestConfig->SetTimeInterval(1);
567 request->SetUid(111);
568 request->SetPid(222);
569 request->SetPackageName("nameForTest");
570 request->SetRequestConfig(*requestConfig);
571 request->SetRequesting(true);
572 request->SetUuid(std::to_string(35279));
573 request->SetNlpRequestType(0);
574 auto locatorCallbackHostForTest =
575 sptr<LocatorCallbackNapi>(new (std::nothrow) LocatorCallbackNapi());
576 sptr<ILocatorCallback> locatorCallback =
577 sptr<ILocatorCallback>(locatorCallbackHostForTest);
578 request->SetLocatorCallBack(locatorCallback);
579 std::unique_ptr<Location> finalLocation = std::make_unique<Location>();
580 finalLocation->SetUuid("35279");
581 reportManager_->ReportLocationByCallback(request, finalLocation);
582 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportLocationByCallback001 end");
583 }
584
585 HWTEST_F(ReportManagerTest, ReportLocationByCallback002, TestSize.Level1)
586 {
587 GTEST_LOG_(INFO)
588 << "ReportManagerTest, ReportLocationByCallback002, TestSize.Level1";
589 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportLocationByCallback002 begin");
590 std::shared_ptr<Request> request = std::make_shared<Request>();
591 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
592 requestConfig->SetTimeInterval(1);
593 request->SetUid(111);
594 request->SetPid(222);
595 request->SetPackageName("nameForTest");
596 request->SetRequestConfig(*requestConfig);
597 request->SetRequesting(true);
598 request->SetUuid(std::to_string(35279));
599 request->SetNlpRequestType(0);
600 std::unique_ptr<Location> finalLocation = std::make_unique<Location>();
601 finalLocation->SetUuid("35279");
602 reportManager_->ReportLocationByCallback(request, finalLocation);
603 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ReportLocationByCallback002 end");
604 }
605
606 HWTEST_F(ReportManagerTest, LocationReportDelayTimeCheck001, TestSize.Level1)
607 {
608 GTEST_LOG_(INFO)
609 << "ReportManagerTest, LocationReportDelayTimeCheck001, TestSize.Level1";
610 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] LocationReportDelayTimeCheck001 begin");
611 std::shared_ptr<Request> request = std::make_shared<Request>();
612 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
613 requestConfig->SetTimeInterval(1);
614 request->SetUid(111);
615 request->SetPid(222);
616 request->SetPackageName("nameForTest");
617 request->SetRequestConfig(*requestConfig);
618 request->SetRequesting(true);
619 request->SetUuid(std::to_string(35279));
620 request->SetNlpRequestType(0);
621 std::unique_ptr<Location> finalLocation = std::make_unique<Location>();
622 finalLocation->SetUuid("35279");
623 reportManager_->LocationReportDelayTimeCheck(finalLocation, request);
624 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] LocationReportDelayTimeCheck001 end");
625 }
626
627 HWTEST_F(ReportManagerTest, ExecuteReportProcess001, TestSize.Level1)
628 {
629 GTEST_LOG_(INFO)
630 << "ReportManagerTest, ExecuteReportProcess001, TestSize.Level1";
631 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ExecuteReportProcess001 begin");
632 std::shared_ptr<Request> request = std::make_shared<Request>();
633 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
634 requestConfig->SetTimeInterval(1);
635 request->SetUid(111);
636 request->SetPid(222);
637 request->SetPackageName("nameForTest");
638 request->SetRequestConfig(*requestConfig);
639 request->SetRequesting(true);
640 request->SetUuid(std::to_string(35279));
641 request->SetNlpRequestType(0);
642 std::unique_ptr<Location> finalLocation = std::make_unique<Location>();
643 finalLocation->SetUuid("35279");
644 std::string abilityName = "ExecuteReportProcess001";
645 reportManager_->ExecuteReportProcess(request, finalLocation, abilityName);
646 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ExecuteReportProcess001 end");
647 }
648
649 HWTEST_F(ReportManagerTest, IsCacheGnssLocationValid001, TestSize.Level1)
650 {
651 GTEST_LOG_(INFO)
652 << "ReportManagerTest, IsCacheGnssLocationValid001, TestSize.Level1";
653 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsCacheGnssLocationValid001 begin");
654 reportManager_->IsCacheGnssLocationValid();
655 LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsCacheGnssLocationValid001 end");
656 }
657 } // namespace Location
658 } // namespace OHOS