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