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 "request_manager_test.h"
17 
18 #include "accesstoken_kit.h"
19 #include "app_mgr_constants.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 
23 #include "i_locator_callback.h"
24 #define private public
25 #include "locator_ability.h"
26 #undef private
27 #include "locator_callback_host.h"
28 #include "request.h"
29 #include "request_config.h"
30 #include "permission_manager.h"
31 
32 using namespace testing::ext;
33 
34 namespace OHOS {
35 namespace Location {
36 const int32_t LOCATION_PERM_NUM = 5;
37 const int UNKNOWN_PRIORITY = 0x01FF;
38 const int UNKNOWN_SCENE = 0x02FF;
SetUp()39 void RequestManagerTest::SetUp()
40 {
41     MockNativePermission();
42     requestManager_ = RequestManager::GetInstance();
43     EXPECT_NE(nullptr, requestManager_);
44     request_ = std::make_shared<Request>();
45     EXPECT_NE(nullptr, request_);
46     request_->SetUid(SYSTEM_UID);
47     request_->SetPid(0);
48     request_->SetTokenId(tokenId_);
49     request_->SetFirstTokenId(0);
50     request_->SetPackageName("RequestManagerTest");
51     request_->SetRequesting(true);
52     auto requestConfig = std::make_unique<RequestConfig>();
53     EXPECT_NE(nullptr, requestConfig);
54     requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
55     requestConfig->SetFixNumber(0);
56     request_->SetRequestConfig(*requestConfig);
57     sptr<LocatorCallbackHost> locatorCallbackHost =
58         sptr<LocatorCallbackHost>(new (std::nothrow)LocatorCallbackHost());
59     sptr<ILocatorCallback> callback = sptr<ILocatorCallback>(locatorCallbackHost);
60     request_->SetLocatorCallBack(callback);
61 }
62 
TearDown()63 void RequestManagerTest::TearDown()
64 {
65     requestManager_ = nullptr;
66 }
67 
MockNativePermission()68 void RequestManagerTest::MockNativePermission()
69 {
70     const char *perms[] = {
71         ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
72         ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
73         ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
74     };
75     NativeTokenInfoParams infoInstance = {
76         .dcapsNum = 0,
77         .permsNum = LOCATION_PERM_NUM,
78         .aclsNum = 0,
79         .dcaps = nullptr,
80         .perms = perms,
81         .acls = nullptr,
82         .processName = "RequestManagerTest",
83         .aplStr = "system_basic",
84     };
85     tokenId_ = GetAccessTokenId(&infoInstance);
86     SetSelfTokenID(tokenId_);
87     Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
88 }
89 
FillRequestField(std::shared_ptr<Request> & request)90 void RequestManagerTest::FillRequestField(std::shared_ptr<Request>& request)
91 {
92     request->SetUid(SYSTEM_UID);
93     request->SetPid(0);
94     request->SetTokenId(0);
95     request->SetFirstTokenId(0);
96     request->SetPackageName("pkg.name");
97     std::unique_ptr<RequestConfig> requestConfig =
98         std::make_unique<RequestConfig>();
99     request->SetRequestConfig(*requestConfig);
100     request->SetRequesting(false);
101     std::unique_ptr<Location> location = std::make_unique<Location>();
102     request->SetLastLocation(location);
103     request->SetLocationPermState(true);
104     request->SetBackgroundPermState(true);
105     request->SetApproximatelyPermState(true);
106 }
107 
VerifyRequestField(std::shared_ptr<Request> & request)108 void RequestManagerTest::VerifyRequestField(std::shared_ptr<Request>& request)
109 {
110     EXPECT_EQ(SYSTEM_UID, request->GetUid());
111     EXPECT_EQ(0, request->GetPid());
112     EXPECT_EQ(0, request->GetTokenId());
113     EXPECT_EQ(0, request->GetFirstTokenId());
114     EXPECT_EQ("pkg.name", request->GetPackageName());
115     EXPECT_NE(nullptr, request->GetRequestConfig());
116     request->GetLocatorCallBack();
117     EXPECT_EQ(false, request->GetIsRequesting());
118     EXPECT_NE(nullptr, request->GetLastLocation());
119     EXPECT_EQ(true, request->GetLocationPermState());
120     EXPECT_EQ(true, request->GetBackgroundPermState());
121     EXPECT_EQ(true, request->GetApproximatelyPermState());
122 }
123 
124 HWTEST_F(RequestManagerTest, InitSystemListeners001, TestSize.Level1)
125 {
126     GTEST_LOG_(INFO)
127         << "RequestManagerTest, InitSystemListeners001, TestSize.Level1";
128     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] InitSystemListeners001 begin");
129     EXPECT_EQ(true, requestManager_->InitSystemListeners());
130     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] InitSystemListeners001 end");
131 }
132 
133 HWTEST_F(RequestManagerTest, HandleStartAndStopLocating001, TestSize.Level1)
134 {
135     GTEST_LOG_(INFO)
136         << "RequestManagerTest, HandleStartAndStopLocating001, TestSize.Level1";
137     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleStartAndStopLocating001 begin");
138     ASSERT_TRUE(requestManager_ != nullptr);
139     auto locatorAbility = LocatorAbility::GetInstance();
140     locatorAbility->receivers_ = nullptr;
141     requestManager_->HandleStartLocating(request_);
142     requestManager_->HandleStopLocating(nullptr); // can't stop locating
143 
144     requestManager_->HandleStartLocating(request_); // can start locating
145     requestManager_->HandleStopLocating(callback_); // can stop locating
146 
147     locatorAbility->receivers_ = nullptr;
148     requestManager_->HandleStartLocating(request_); // can't start locating
149     requestManager_->HandleStopLocating(callback_); // can stop locating, but not locating
150     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleStartAndStopLocating001 end");
151 }
152 
153 HWTEST_F(RequestManagerTest, HandleStartAndStopLocating002, TestSize.Level1)
154 {
155     GTEST_LOG_(INFO)
156         << "RequestManagerTest, HandleStartAndStopLocating002, TestSize.Level1";
157     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleStartAndStopLocating002 begin");
158     ASSERT_TRUE(requestManager_ != nullptr);
159     std::shared_ptr<Request> request = std::make_shared<Request>();
160 
161     request->SetUid(SYSTEM_UID);
162     request->SetPid(0);
163     request->SetTokenId(tokenId_);
164     request->SetFirstTokenId(0);
165     request->SetPackageName("RequestManagerTest");
166     auto requestConfig = std::make_unique<RequestConfig>();
167     requestConfig->SetPriority(PRIORITY_FAST_FIRST_FIX);
168     requestConfig->SetFixNumber(0);
169     request->SetRequestConfig(*requestConfig);
170     sptr<LocatorCallbackHost> locatorCallbackHost =
171         sptr<LocatorCallbackHost>(new (std::nothrow)LocatorCallbackHost());
172     auto callback = sptr<ILocatorCallback>(locatorCallbackHost);
173     request->SetLocatorCallBack(callback);
174     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleStartAndStopLocating002 end");
175 }
176 
177 HWTEST_F(RequestManagerTest, HandlePowerSuspendChanged001, TestSize.Level1)
178 {
179     GTEST_LOG_(INFO)
180         << "RequestManagerTest, HandlePowerSuspendChanged001, TestSize.Level1";
181     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged001 begin");
182     requestManager_->UpdateRequestRecord(request_, true);
183     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
184     int32_t state1 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND);
185     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
186         request_->GetUid(), state1);
187     int32_t state2 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND);
188     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
189         request_->GetUid(), state2);
190     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged001 end");
191 }
192 
193 HWTEST_F(RequestManagerTest, HandlePowerSuspendChanged002, TestSize.Level1)
194 {
195     GTEST_LOG_(INFO)
196         << "RequestManagerTest, HandlePowerSuspendChanged002, TestSize.Level1";
197     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged002 begin");
198     ASSERT_TRUE(requestManager_ != nullptr);
199     requestManager_->UpdateRequestRecord(request_, false);
200     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
201 
202     int32_t state1 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND);
203     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
204         request_->GetUid(), state1);
205     int32_t state2 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND);
206     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
207         request_->GetUid(), state2);
208     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged002 end");
209 }
210 
211 HWTEST_F(RequestManagerTest, HandlePowerSuspendChanged003, TestSize.Level1)
212 {
213     GTEST_LOG_(INFO)
214         << "RequestManagerTest, HandlePowerSuspendChanged003, TestSize.Level1";
215     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged003 begin");
216     ASSERT_TRUE(requestManager_ != nullptr);
217     requestManager_->UpdateRequestRecord(request_, false);
218     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
219 
220     int32_t state1 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND);
221     requestManager_->HandlePowerSuspendChanged(request_->GetPid() + 1,
222         request_->GetUid(), state1);
223     int32_t state2 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND);
224     requestManager_->HandlePowerSuspendChanged(request_->GetPid() + 1,
225         request_->GetUid(), state2);
226     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged003 end");
227 }
228 
229 HWTEST_F(RequestManagerTest, HandlePowerSuspendChanged004, TestSize.Level1)
230 {
231     GTEST_LOG_(INFO)
232         << "RequestManagerTest, HandlePowerSuspendChanged004, TestSize.Level1";
233     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged004 begin");
234     ASSERT_TRUE(requestManager_ != nullptr);
235     requestManager_->UpdateRequestRecord(request_, false);
236     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
237 
238     int32_t state1 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND);
239     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
240         request_->GetUid() + 1, state1);
241     int32_t state2 = static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND);
242     requestManager_->HandlePowerSuspendChanged(request_->GetPid(),
243         request_->GetUid() + 1, state2);
244     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandlePowerSuspendChanged004 end");
245 }
246 
247 HWTEST_F(RequestManagerTest, UpdateRequestRecord001, TestSize.Level1)
248 {
249     GTEST_LOG_(INFO)
250         << "RequestManagerTest, UpdateRequestRecord001, TestSize.Level1";
251     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateRequestRecord001 begin");
252     requestManager_->UpdateRequestRecord(request_, true); // uid = 1000 should be added to runningUids
253     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
254     requestManager_->UpdateRequestRecord(request_, false); // uid = 1000 should be removed from runningUids
255     EXPECT_EQ(true, requestManager_->IsUidInProcessing(SYSTEM_UID));
256     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateRequestRecord001 end");
257 }
258 
259 HWTEST_F(RequestManagerTest, UpdateUsingPermissionTest001, TestSize.Level1)
260 {
261     GTEST_LOG_(INFO)
262         << "RequestManagerTest, UpdateUsingPermissionTest001, TestSize.Level1";
263     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest001 begin");
264     ASSERT_TRUE(requestManager_ != nullptr);
265     requestManager_->UpdateUsingPermission(nullptr, true);
266     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest001 end");
267 }
268 
269 HWTEST_F(RequestManagerTest, UpdateUsingPermissionTest002, TestSize.Level1)
270 {
271     GTEST_LOG_(INFO)
272         << "RequestManagerTest, UpdateUsingPermissionTest002, TestSize.Level1";
273     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest002 begin");
274     EXPECT_EQ(false, request_->GetLocationPermState());
275     EXPECT_EQ(false, request_->GetBackgroundPermState());
276     EXPECT_EQ(false, request_->GetApproximatelyPermState());
277     requestManager_->UpdateUsingPermission(request_, true);
278     EXPECT_EQ(false, request_->GetLocationPermState());
279     EXPECT_EQ(false, request_->GetBackgroundPermState());
280     EXPECT_EQ(true, request_->GetApproximatelyPermState());
281     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest002 end");
282 }
283 
284 HWTEST_F(RequestManagerTest, UpdateUsingPermissionTest003, TestSize.Level1)
285 {
286     GTEST_LOG_(INFO)
287         << "RequestManagerTest, UpdateUsingPermissionTest003, TestSize.Level1";
288     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest003 begin");
289     requestManager_->UpdateRequestRecord(request_, true);
290     EXPECT_EQ(false, request_->GetLocationPermState());
291     EXPECT_EQ(false, request_->GetBackgroundPermState());
292     EXPECT_EQ(false, request_->GetApproximatelyPermState());
293     requestManager_->UpdateUsingPermission(request_, true);
294     // location permission is not recorded
295     EXPECT_EQ(false, request_->GetLocationPermState());
296     EXPECT_EQ(false, request_->GetBackgroundPermState());
297     // background location permission is not recorded
298     EXPECT_EQ(true, request_->GetApproximatelyPermState());
299 
300     requestManager_->UpdateRequestRecord(request_, false);
301     // location permission is not recorded
302     EXPECT_EQ(false, request_->GetLocationPermState());
303     // background location permission is not recorded
304     EXPECT_EQ(false, request_->GetBackgroundPermState());
305     EXPECT_EQ(true, request_->GetApproximatelyPermState());
306     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateUsingPermissionTest003 end");
307 }
308 
309 HWTEST_F(RequestManagerTest, DeleteRequestRecord001, TestSize.Level1)
310 {
311     GTEST_LOG_(INFO)
312         << "RequestManagerTest, DeleteRequestRecord001, TestSize.Level1";
313     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] DeleteRequestRecord001 begin");
314     auto requests = std::make_shared<std::list<std::shared_ptr<Request>>>();
315     std::shared_ptr<Request> request = std::make_shared<Request>();
316     requests->push_back(request);
317     requestManager_->DeleteRequestRecord(requests);
318     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] DeleteRequestRecord001 end");
319 }
320 
321 HWTEST_F(RequestManagerTest, RequestTest001, TestSize.Level1)
322 {
323     GTEST_LOG_(INFO)
324         << "RequestManagerTest, RequestTest001, TestSize.Level1";
325     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestTest001 begin");
326     std::shared_ptr<Request> request = std::make_shared<Request>();
327     FillRequestField(request);
328     VerifyRequestField(request);
329     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestTest001 end");
330 }
331 
332 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest001, TestSize.Level1)
333 {
334     GTEST_LOG_(INFO)
335         << "RequestManagerTest, RequestGetProxyNameTest001, TestSize.Level1";
336     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest001 begin");
337     std::shared_ptr<Request> request = std::make_shared<Request>();
338     std::shared_ptr<std::list<std::string>> proxyList = nullptr;
339     request->GetProxyName(proxyList);
340     EXPECT_EQ(nullptr, proxyList);
341     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest001 end");
342 }
343 
344 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest002, TestSize.Level1)
345 {
346     GTEST_LOG_(INFO)
347         << "RequestManagerTest, RequestGetProxyNameTest002, TestSize.Level1";
348     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest002 begin");
349     std::shared_ptr<Request> request = std::make_shared<Request>();
350     std::unique_ptr<RequestConfig> requestConfig1 =
351         std::make_unique<RequestConfig>();
352     requestConfig1->SetScenario(SCENE_NAVIGATION);
353     request->SetRequestConfig(*requestConfig1);
354     auto proxyList1 = std::make_shared<std::list<std::string>>();
355     request->GetProxyName(proxyList1);
356     EXPECT_NE(true, proxyList1->empty());
357     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest002 end");
358 }
359 
360 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest003, TestSize.Level1)
361 {
362     GTEST_LOG_(INFO)
363         << "RequestManagerTest, RequestGetProxyNameTest003, TestSize.Level1";
364     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest003 begin");
365     std::shared_ptr<Request> request = std::make_shared<Request>();
366     std::unique_ptr<RequestConfig> requestConfig2 =
367         std::make_unique<RequestConfig>();
368     requestConfig2->SetScenario(SCENE_TRAJECTORY_TRACKING);
369     request->SetRequestConfig(*requestConfig2);
370     auto proxyList2 = std::make_shared<std::list<std::string>>();
371     request->GetProxyName(proxyList2);
372     EXPECT_NE(true, proxyList2->empty());
373     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest003 end");
374 }
375 
376 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest004, TestSize.Level1)
377 {
378     GTEST_LOG_(INFO)
379         << "RequestManagerTest, RequestGetProxyNameTest004, TestSize.Level1";
380     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest004 begin");
381     std::shared_ptr<Request> request = std::make_shared<Request>();
382     std::unique_ptr<RequestConfig> requestConfig3 =
383         std::make_unique<RequestConfig>();
384     requestConfig3->SetScenario(SCENE_CAR_HAILING);
385     request->SetRequestConfig(*requestConfig3);
386     auto proxyList3 = std::make_shared<std::list<std::string>>();
387     request->GetProxyName(proxyList3);
388     EXPECT_NE(true, proxyList3->empty());
389     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest004 end");
390 }
391 
392 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest005, TestSize.Level1)
393 {
394     GTEST_LOG_(INFO)
395         << "RequestManagerTest, RequestGetProxyNameTest005, TestSize.Level1";
396     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest005 begin");
397     std::shared_ptr<Request> request = std::make_shared<Request>();
398     std::unique_ptr<RequestConfig> requestConfig4 =
399         std::make_unique<RequestConfig>();
400     requestConfig4->SetScenario(SCENE_DAILY_LIFE_SERVICE);
401     request->SetRequestConfig(*requestConfig4);
402     auto proxyList4 = std::make_shared<std::list<std::string>>();
403     request->GetProxyName(proxyList4);
404     EXPECT_NE(true, proxyList4->empty());
405     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest005 end");
406 }
407 
408 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest006, TestSize.Level1)
409 {
410     GTEST_LOG_(INFO)
411         << "RequestManagerTest, RequestGetProxyNameTest006, TestSize.Level1";
412     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest006 begin");
413     std::shared_ptr<Request> request = std::make_shared<Request>();
414     std::unique_ptr<RequestConfig> requestConfig5 =
415         std::make_unique<RequestConfig>();
416     requestConfig5->SetScenario(SCENE_NO_POWER);
417     request->SetRequestConfig(*requestConfig5);
418     auto proxyList5 = std::make_shared<std::list<std::string>>();
419     request->GetProxyName(proxyList5);
420     EXPECT_NE(true, proxyList5->empty());
421     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest006 end");
422 }
423 
424 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest007, TestSize.Level1)
425 {
426     GTEST_LOG_(INFO)
427         << "RequestManagerTest, RequestGetProxyNameTest007, TestSize.Level1";
428     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest007 begin");
429     std::shared_ptr<Request> request = std::make_shared<Request>();
430     std::unique_ptr<RequestConfig> requestConfig6 =
431         std::make_unique<RequestConfig>();
432     requestConfig6->SetScenario(SCENE_UNSET);
433     requestConfig6->SetPriority(PRIORITY_ACCURACY);
434     request->SetRequestConfig(*requestConfig6);
435     auto proxyList6 = std::make_shared<std::list<std::string>>();
436     request->GetProxyName(proxyList6);
437     EXPECT_NE(true, proxyList6->empty());
438     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest007 end");
439 }
440 
441 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest008, TestSize.Level1)
442 {
443     GTEST_LOG_(INFO)
444         << "RequestManagerTest, RequestGetProxyNameTest008, TestSize.Level1";
445     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest008 begin");
446     std::shared_ptr<Request> request = std::make_shared<Request>();
447     std::unique_ptr<RequestConfig> requestConfig7 =
448         std::make_unique<RequestConfig>();
449     requestConfig7->SetScenario(SCENE_UNSET);
450     requestConfig7->SetPriority(PRIORITY_LOW_POWER);
451     request->SetRequestConfig(*requestConfig7);
452     auto proxyList7 = std::make_shared<std::list<std::string>>();
453     request->GetProxyName(proxyList7);
454     EXPECT_NE(true, proxyList7->empty());
455     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest008 end");
456 }
457 
458 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest009, TestSize.Level1)
459 {
460     GTEST_LOG_(INFO)
461         << "RequestManagerTest, RequestGetProxyNameTest009, TestSize.Level1";
462     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest009 begin");
463     std::shared_ptr<Request> request = std::make_shared<Request>();
464     std::unique_ptr<RequestConfig> requestConfig8 =
465         std::make_unique<RequestConfig>();
466     requestConfig8->SetScenario(SCENE_UNSET);
467     requestConfig8->SetPriority(PRIORITY_FAST_FIRST_FIX);
468     request->SetRequestConfig(*requestConfig8);
469     auto proxyList8 = std::make_shared<std::list<std::string>>();
470     request->GetProxyName(proxyList8);
471     EXPECT_NE(true, proxyList8->empty());
472     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest009 end");
473 }
474 
475 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest010, TestSize.Level1)
476 {
477     GTEST_LOG_(INFO)
478         << "RequestManagerTest, RequestGetProxyNameTest010, TestSize.Level1";
479     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest010 begin");
480     std::shared_ptr<Request> request = std::make_shared<Request>();
481     std::unique_ptr<RequestConfig> requestConfig9 =
482         std::make_unique<RequestConfig>();
483     requestConfig9->SetScenario(SCENE_UNSET);
484     requestConfig9->SetPriority(UNKNOWN_PRIORITY);
485     request->SetRequestConfig(*requestConfig9);
486     auto proxyList9 = std::make_shared<std::list<std::string>>();
487     request->GetProxyName(proxyList9);
488     EXPECT_EQ(true, proxyList9->empty());
489     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest010 end");
490 }
491 
492 HWTEST_F(RequestManagerTest, RequestGetProxyNameTest011, TestSize.Level1)
493 {
494     GTEST_LOG_(INFO)
495         << "RequestManagerTest, RequestGetProxyNameTest011, TestSize.Level1";
496     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest011 begin");
497     std::shared_ptr<Request> request = std::make_shared<Request>();
498     std::unique_ptr<RequestConfig> requestConfig10 =
499         std::make_unique<RequestConfig>();
500     requestConfig10->SetScenario(UNKNOWN_SCENE);
501     request->SetRequestConfig(*requestConfig10);
502     auto proxyList10 = std::make_shared<std::list<std::string>>();
503     request->GetProxyName(proxyList10);
504     EXPECT_EQ(true, proxyList10->empty());
505     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] RequestGetProxyNameTest011 end");
506 }
507 
508 HWTEST_F(RequestManagerTest, GetRemoteObject001, TestSize.Level1)
509 {
510     GTEST_LOG_(INFO)
511         << "RequestManagerTest, GetRemoteObject001, TestSize.Level1";
512     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] GetRemoteObject001 begin");
513     ASSERT_TRUE(requestManager_ != nullptr);
514     requestManager_->GetRemoteObject(GNSS_ABILITY);
515 
516     requestManager_->GetRemoteObject("");
517     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] GetRemoteObject001 end");
518 }
519 
520 HWTEST_F(RequestManagerTest, HandleChrEvent001, TestSize.Level1)
521 {
522     GTEST_LOG_(INFO)
523         << "RequestManagerTest, HandleChrEvent001, TestSize.Level1";
524     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleChrEvent001 begin");
525     ASSERT_TRUE(requestManager_ != nullptr);
526     std::list<std::shared_ptr<Request>> requests;
527     std::shared_ptr<Request> request = std::make_shared<Request>();
528     requests.push_back(request);
529     requestManager_->HandleChrEvent(requests);
530     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleChrEvent001 end");
531 }
532 
533 HWTEST_F(RequestManagerTest, HandleChrEvent002, TestSize.Level1)
534 {
535     GTEST_LOG_(INFO)
536         << "RequestManagerTest, HandleChrEvent002, TestSize.Level1";
537     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleChrEvent002 begin");
538     ASSERT_TRUE(requestManager_ != nullptr);
539     std::list<std::shared_ptr<Request>> requests;
540     for (int i = 0; i < 25 ; i++) {
541         std::shared_ptr<Request> request = std::make_shared<Request>();
542         requests.push_back(request);
543     }
544     requestManager_->HandleChrEvent(requests);
545     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] HandleChrEvent002 end");
546 }
547 
548 HWTEST_F(RequestManagerTest, IsUidInProcessing001, TestSize.Level1)
549 {
550     GTEST_LOG_(INFO)
551         << "RequestManagerTest, IsUidInProcessing001, TestSize.Level1";
552     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] IsUidInProcessing001 begin");
553     ASSERT_TRUE(requestManager_ != nullptr);
554     requestManager_->IsUidInProcessing(0);
555     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] IsUidInProcessing001 end");
556 }
557 
558 HWTEST_F(RequestManagerTest, UpdateLocationErrorCallbackToRequest001, TestSize.Level1)
559 {
560     GTEST_LOG_(INFO)
561         << "RequestManagerTest, UpdateLocationErrorCallbackToRequest001, TestSize.Level1";
562     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateLocationErrorCallbackToRequest001 begin");
563     ASSERT_TRUE(requestManager_ != nullptr);
564     std::shared_ptr<Request> request = std::make_shared<Request>();
565     requestManager_->UpdateLocationError(request);
566     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] UpdateLocationErrorCallbackToRequest001 end");
567 }
568 
569 HWTEST_F(RequestManagerTest, SyncStillMovementState001, TestSize.Level1)
570 {
571     GTEST_LOG_(INFO)
572         << "RequestManagerTest, SyncStillMovementState001, TestSize.Level1";
573     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] SyncStillMovementState001 begin");
574     ASSERT_TRUE(requestManager_ != nullptr);
575     requestManager_->SyncStillMovementState(true);
576     LBSLOGI(REQUEST_MANAGER, "[RequestManagerTest] SyncStillMovementState001 end");
577 }
578 }  // namespace Location
579 }  // namespace OHOS