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     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest001 end");
162 }
163 
164 HWTEST_F(ReportManagerTest, ResultCheckTest002, TestSize.Level1)
165 {
166     GTEST_LOG_(INFO)
167         << "ReportManagerTest, ResultCheckTest002, TestSize.Level1";
168     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest002 begin");
169     std::shared_ptr<Request> request = std::make_shared<Request>();
170     request->SetUid(1000);
171     request->SetPid(0);
172     request->SetTokenId(tokenId_);
173     request->SetFirstTokenId(0);
174     request->SetPackageName("ReportManagerTest");
175     auto requestConfig = std::make_unique<RequestConfig>();
176     EXPECT_NE(nullptr, requestConfig);
177     requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
178     requestConfig->SetMaxAccuracy(1000.0);
179     requestConfig->SetFixNumber(1);
180     request->SetRequestConfig(*requestConfig);
181     auto location = MockLocation();
182 
183     std::unique_ptr<Location> lastLocation5 = std::make_unique<Location>(*location);
184     lastLocation5->SetTimeSinceBoot(1000000000);
185     requestConfig->SetDistanceInterval(0.0);
186     requestConfig->SetMaxAccuracy(0.0);
187     request->SetRequestConfig(*requestConfig);
188     request->SetLastLocation(lastLocation5);
189     reportManager_->ResultCheck(location, request); // check pass
190     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ResultCheckTest002 end");
191 }
192 
193 HWTEST_F(ReportManagerTest, SetLastLocationTest001, TestSize.Level1)
194 {
195     GTEST_LOG_(INFO)
196         << "ReportManagerTest, SetLastLocationTest001, TestSize.Level1";
197     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] SetLastLocationTest001 begin");
198     reportManager_->GetLastLocation();
199     int64_t curTime = CommonUtils::GetCurrentTimeStamp();
200     MessageParcel parcel;
201     parcel.WriteDouble(12.0); // latitude
202     parcel.WriteDouble(13.0); // longitude
203     parcel.WriteDouble(14.0); // altitude
204     parcel.WriteDouble(1000.0); // accuracy
205     parcel.WriteDouble(10.0); // speed
206     parcel.WriteDouble(90.0); // direction
207     parcel.WriteInt64(curTime * MILLI_PER_SEC); // timeStamp
208     parcel.WriteInt64(1000000000); // timeSinceBoot
209     parcel.WriteString16(u"additions"); // additions
210     parcel.WriteInt64(1); // additionSize
211     parcel.WriteInt32(1); // isFromMock
212     std::unique_ptr<Location> location = std::make_unique<Location>();
213     location->ReadFromParcel(parcel);
214     reportManager_->UpdateCacheLocation(location, GNSS_ABILITY);
215     std::shared_ptr<Request> request = std::make_shared<Request>();
216     request->SetUid(1000);
217     request->SetPid(0);
218     request->SetTokenId(tokenId_);
219     request->SetFirstTokenId(0);
220     request->SetPackageName("ReportManagerTest");
221     EXPECT_NE(nullptr, reportManager_->GetLastLocation());
222     reportManager_->GetCacheLocation(request);
223     reportManager_->UpdateCacheLocation(location, NETWORK_ABILITY);
224     reportManager_->GetCacheLocation(request);
225     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] SetLastLocationTest001 end");
226 }
227 
228 HWTEST_F(ReportManagerTest, GetPermittedLocationTest001, TestSize.Level1)
229 {
230     GTEST_LOG_(INFO)
231         << "ReportManagerTest, GetPermittedLocationTest001, TestSize.Level1";
232     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] GetPermittedLocationTest001 begin");
233     std::shared_ptr<Request> request = std::make_shared<Request>();
234     request->SetTokenId(tokenId_);
235     EXPECT_EQ(nullptr, reportManager_->GetPermittedLocation(request, nullptr));
236     MessageParcel parcel;
237     parcel.WriteDouble(12.0); // latitude
238     parcel.WriteDouble(13.0); // longitude
239     parcel.WriteDouble(14.0); // altitude
240     parcel.WriteDouble(1000.0); // accuracy
241     parcel.WriteDouble(10.0); // speed
242     parcel.WriteDouble(90.0); // direction
243     parcel.WriteInt64(1000000000); // timeStamp
244     parcel.WriteInt64(1000000000); // timeSinceBoot
245     parcel.WriteString16(u"additions"); // additions
246     parcel.WriteInt64(1); // additionSize
247     parcel.WriteInt32(1); // isFromMock
248     std::unique_ptr<Location> location = std::make_unique<Location>();
249     location->ReadFromParcel(parcel);
250     auto newLocation = reportManager_->GetPermittedLocation(request, location);
251     EXPECT_NE(nullptr, newLocation);
252     if (newLocation != nullptr) {
253         EXPECT_EQ(12.0, newLocation->GetLatitude());
254         EXPECT_EQ(13.0, newLocation->GetLongitude());
255         EXPECT_EQ(1000.0, newLocation->GetAccuracy());
256         LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] GetPermittedLocationTest001 end");
257     }
258 }
259 
260 HWTEST_F(ReportManagerTest, OnReportLocationTest001, TestSize.Level1)
261 {
262     GTEST_LOG_(INFO)
263         << "ReportManagerTest, OnReportLocationTest001, TestSize.Level1";
264     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest001 begin");
265     MessageParcel parcel;
266     parcel.WriteDouble(12.0); // latitude
267     parcel.WriteDouble(13.0); // longitude
268     parcel.WriteDouble(14.0); // altitude
269     parcel.WriteDouble(1000.0); // accuracy
270     parcel.WriteDouble(10.0); // speed
271     parcel.WriteDouble(90.0); // direction
272     parcel.WriteInt64(1000000000); // timeStamp
273     parcel.WriteInt64(1000000000); // timeSinceBoot
274     parcel.WriteString16(u"additions"); // additions
275     parcel.WriteInt64(1); // additionSize
276     parcel.WriteInt32(0); // isFromMock
277     std::unique_ptr<Location> location = std::make_unique<Location>();
278     location->ReadFromParcel(parcel);
279     location->SetUuid("35279");
280     reportManager_->UpdateCacheLocation(location, NETWORK_ABILITY);
281     std::list<std::shared_ptr<Request>> networkList;
282     int num = 2;
283     for (int i = 0; i < num; i++) {
284         std::shared_ptr<Request> request = std::make_shared<Request>();
285         std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
286         requestConfig->SetPriority(PRIORITY_ACCURACY);
287         requestConfig->SetTimeOut(120000);
288         requestConfig->SetScenario(SCENE_DAILY_LIFE_SERVICE);
289         requestConfig->SetFixNumber(1);
290         requestConfig->SetTimeInterval(i);
291         requestConfig->SetMaxAccuracy(20.0);
292         request->SetUid(i + 1);
293         request->SetPid(i + 2);
294         request->SetPackageName("nameForTest");
295         request->SetRequestConfig(*requestConfig);
296         request->SetUuid(std::to_string(i + 35279));
297         request->SetNlpRequestType(0);
298         networkList.push_back(request);
299     }
300     auto locatorAbility = LocatorAbility::GetInstance();
301     locatorAbility->requests_->insert(make_pair(NETWORK_ABILITY, networkList));
302 
303     EXPECT_EQ(true, reportManager_->OnReportLocation(location, NETWORK_ABILITY));
304     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest001 end");
305 }
306 
307 HWTEST_F(ReportManagerTest, OnReportLocationTest002, TestSize.Level1)
308 {
309     GTEST_LOG_(INFO)
310         << "ReportManagerTest, OnReportLocationTest002, TestSize.Level1";
311     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest002 begin");
312     MessageParcel parcel;
313     parcel.WriteDouble(12.0); // latitude
314     parcel.WriteDouble(13.0); // longitude
315     parcel.WriteDouble(14.0); // altitude
316     parcel.WriteDouble(1000.0); // accuracy
317     parcel.WriteDouble(10.0); // speed
318     parcel.WriteDouble(90.0); // direction
319     parcel.WriteInt64(1000000000); // timeStamp
320     parcel.WriteInt64(1000000000); // timeSinceBoot
321     parcel.WriteString16(u"additions"); // additions
322     parcel.WriteInt64(1); // additionSize
323     parcel.WriteInt32(0); // isFromMock
324     std::unique_ptr<Location> location = std::make_unique<Location>();
325     location->ReadFromParcel(parcel);
326     EXPECT_EQ(true, reportManager_->OnReportLocation(location, GNSS_ABILITY)); // is not requesting
327     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest002 end");
328 }
329 
330 HWTEST_F(ReportManagerTest, OnReportLocationTest003, TestSize.Level1)
331 {
332     GTEST_LOG_(INFO)
333         << "ReportManagerTest, OnReportLocationTest003, TestSize.Level1";
334     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest003 begin");
335     MessageParcel parcel;
336     parcel.WriteDouble(12.0);         // latitude
337     parcel.WriteDouble(13.0);         // longitude
338     parcel.WriteDouble(14.0);         // altitude
339     parcel.WriteDouble(1000.0);       // accuracy
340     parcel.WriteDouble(10.0);         // speed
341     parcel.WriteDouble(90.0);         // direction
342     parcel.WriteInt64(1000000000);    // timeStamp
343     parcel.WriteInt64(1000000000);    // timeSinceBoot
344     parcel.WriteString16(u"additions"); // additions
345     parcel.WriteInt64(1);             // additionSize
346     parcel.WriteInt32(0);          // isFromMock
347     std::unique_ptr<Location> location = std::make_unique<Location>();
348     location->ReadFromParcel(parcel);
349     EXPECT_EQ(true, reportManager_->OnReportLocation(location, GNSS_ABILITY)); // report location successfully
350     EXPECT_EQ(true,
351         reportManager_->OnReportLocation(location, GNSS_ABILITY)); // report the same location, result check is false
352     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest003 end");
353 }
354 
355 HWTEST_F(ReportManagerTest, OnReportLocationTest004, TestSize.Level1)
356 {
357     GTEST_LOG_(INFO)
358         << "ReportManagerTest, OnReportLocationTest004, TestSize.Level1";
359     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest004 begin");
360     MessageParcel parcel;
361     parcel.WriteDouble(12.0);         // latitude
362     parcel.WriteDouble(13.0);         // longitude
363     parcel.WriteDouble(14.0);         // altitude
364     parcel.WriteDouble(10.0);       // accuracy
365     parcel.WriteDouble(10.0);         // speed
366     parcel.WriteDouble(90.0);         // direction
367     parcel.WriteInt64(1000000000);    // timeStamp
368     parcel.WriteInt64(1000000000);    // timeSinceBoot
369     parcel.WriteString16(u"additions"); // additions
370     parcel.WriteInt64(1);             // additionSize
371     parcel.WriteInt32(0);          // isFromMock
372     std::unique_ptr<Location> location = std::make_unique<Location>();
373     std::shared_ptr<Request> request = std::make_shared<Request>();
374     location->ReadFromParcel(parcel);
375     EXPECT_EQ(true, reportManager_->OnReportLocation(location, GNSS_ABILITY)); // will resolve deadRequests
376     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] OnReportLocationTest004 end");
377 }
378 
379 HWTEST_F(ReportManagerTest, UpdateRandomTest004, TestSize.Level1)
380 {
381     GTEST_LOG_(INFO)
382         << "ReportManagerTest, UpdateRandomTest004, TestSize.Level1";
383     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateRandomTest004 begin");
384     std::list<std::shared_ptr<Request>> gnssList;
385     auto locatorAbility = sptr<LocatorAbility>(new (std::nothrow) LocatorAbility());
386     locatorAbility->requests_->insert(make_pair(GNSS_ABILITY, gnssList));
387     reportManager_->UpdateRandom();
388 
389     struct timespec now;
390     clock_gettime(CLOCK_REALTIME, &now);
391     reportManager_->lastUpdateTime_.tv_sec = now.tv_sec + LONG_TIME_INTERVAL +1;
392     locatorAbility->requests_->clear();
393     reportManager_->UpdateRandom();
394     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateRandomTest004 end");
395 }
396 
397 HWTEST_F(ReportManagerTest, IsRequestFuseTest001, TestSize.Level1)
398 {
399     GTEST_LOG_(INFO)
400         << "ReportManagerTest, IsRequestFuseTest001, TestSize.Level1";
401     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest001 begin");
402     EXPECT_EQ(false, reportManager_->IsRequestFuse(nullptr));
403 
404     std::shared_ptr<Request> request = std::make_shared<Request>();
405     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
406     requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
407     requestConfig->SetScenario(SCENE_UNSET);
408     request->SetRequestConfig(*requestConfig);
409     EXPECT_EQ(true, reportManager_->IsRequestFuse(request));
410 
411     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest001 end");
412 }
413 
414 HWTEST_F(ReportManagerTest, IsRequestFuseTest002, TestSize.Level1)
415 {
416     GTEST_LOG_(INFO)
417         << "ReportManagerTest, IsRequestFuseTest002, TestSize.Level1";
418     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest002 begin");
419     EXPECT_EQ(false, reportManager_->IsRequestFuse(nullptr));
420 
421     std::shared_ptr<Request> request = std::make_shared<Request>();
422     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
423     requestConfig->SetPriority(PRIORITY_UNSET);
424     requestConfig->SetScenario(SCENE_UNSET);
425     request->SetRequestConfig(*requestConfig);
426     reportManager_->IsRequestFuse(request);
427 
428     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] IsRequestFuseTest002 end");
429 }
430 
431 HWTEST_F(ReportManagerTest, UpdateLocationByRequestTest001, TestSize.Level1)
432 {
433     GTEST_LOG_(INFO)
434         << "ReportManagerTest, UpdateLocationByRequestTest001, TestSize.Level1";
435     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest001 begin");
436     auto location = MockLocation();
437     reportManager_->UpdateLocationByRequest(tokenId_, tokenId_, location);
438     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest001 end");
439 }
440 
441 HWTEST_F(ReportManagerTest, UpdateLocationByRequestTest002, TestSize.Level1)
442 {
443     GTEST_LOG_(INFO)
444         << "ReportManagerTest, UpdateLocationByRequestTest002, TestSize.Level1";
445     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest002 begin");
446     std::unique_ptr<Location> location = nullptr;
447     reportManager_->UpdateLocationByRequest(tokenId_, tokenId_, location);
448     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] UpdateLocationByRequestTest002 end");
449 }
450 
451 HWTEST_F(ReportManagerTest, ProcessRequestForReport001, TestSize.Level1)
452 {
453     GTEST_LOG_(INFO)
454         << "ReportManagerTest, ProcessRequestForReport001, TestSize.Level1";
455     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport001 begin");
456     std::shared_ptr<Request> request = std::make_shared<Request>();
457     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
458     requestConfig->SetTimeInterval(1);
459     request->SetUid(111);
460     request->SetPid(222);
461     request->SetPackageName("nameForTest");
462     request->SetRequestConfig(*requestConfig);
463     request->SetRequesting(true);
464     request->SetUuid(std::to_string(35279));
465     request->SetNlpRequestType(0);
466     uint32_t tokenId = static_cast<uint32_t>(tokenId_);
467     request->SetTokenId(tokenId);
468     request->SetFirstTokenId(0);
469     auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
470     std::unique_ptr<Location> location = std::make_unique<Location>();
471     location->SetUuid("35279");
472     reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
473     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport001 end");
474 }
475 
476 HWTEST_F(ReportManagerTest, ProcessRequestForReport002, TestSize.Level1)
477 {
478     GTEST_LOG_(INFO)
479         << "ReportManagerTest, ProcessRequestForReport002, TestSize.Level1";
480     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport002 begin");
481     std::shared_ptr<Request> request = std::make_shared<Request>();
482     request->SetUid(111);
483     request->SetPid(222);
484     request->SetPackageName("nameForTest");
485     request->requestConfig_ = nullptr;
486     request->SetRequesting(true);
487     request->SetUuid(std::to_string(35279));
488     request->SetNlpRequestType(0);
489     auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
490     std::unique_ptr<Location> location = std::make_unique<Location>();
491     location->SetUuid("35279");
492     reportManager_->ProcessRequestForReport(request, deadRequests, location, NETWORK_ABILITY);
493     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] ProcessRequestForReport002 end");
494 }
495 
496 HWTEST_F(ReportManagerTest, WriteNetWorkReportEvent, TestSize.Level1)
497 {
498     GTEST_LOG_(INFO)
499         << "ReportManagerTest, WriteNetWorkReportEvent, TestSize.Level1";
500     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] WriteNetWorkReportEvent begin");
501     std::shared_ptr<Request> request = std::make_shared<Request>();
502     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
503     requestConfig->SetTimeInterval(1);
504     request->SetUid(111);
505     request->SetPid(222);
506     request->SetPackageName("nameForTest");
507     request->SetRequestConfig(*requestConfig);
508     request->SetRequesting(true);
509     request->SetUuid(std::to_string(35279));
510     request->SetNlpRequestType(0);
511     std::unique_ptr<Location> location = std::make_unique<Location>();
512     location->SetUuid("35279");
513     reportManager_->WriteNetWorkReportEvent(NETWORK_ABILITY, request, location);
514     LBSLOGI(REPORT_MANAGER, "[ReportManagerTest] WriteNetWorkReportEvent end");
515 }
516 }  // namespace Location
517 }  // namespace OHOS