1 /*
2 * Copyright (c) 2022-2024 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 <gtest/gtest.h>
17
18 #include "ability_foreground_state_observer_interface.h"
19 #include "app_foreground_state_observer_stub.h"
20 #include "app_mgr_proxy.h"
21 #include "hilog_tag_wrapper.h"
22 #include "mock_ability_foreground_state_observer_stub.h"
23 #include "mock_app_mgr_service.h"
24 #include "quick_fix_callback_stub.h"
25 #include "render_state_observer_stub.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace AppExecFwk {
32 namespace {
33 const int32_t USER_ID = 100;
34 constexpr int32_t MAX_BACKGROUND_APP_COUNT = 1000;
35 } // namespace
36
37 class AppForegroundStateObserverMock : public AppForegroundStateObserverStub {
38 public:
39 AppForegroundStateObserverMock() = default;
40 virtual ~AppForegroundStateObserverMock() = default;
41
OnAppStateChanged(const AppStateData & appStateData)42 void OnAppStateChanged(const AppStateData &appStateData) override
43 {}
44 };
45
46 class RenderStateObserverMock : public RenderStateObserverStub {
47 public:
48 RenderStateObserverMock() = default;
49 virtual ~RenderStateObserverMock() = default;
OnRenderStateChanged(const RenderStateData & renderStateData)50 void OnRenderStateChanged(const RenderStateData &renderStateData) override
51 {}
52 };
53
54 class QuickFixCallbackImpl : public AppExecFwk::QuickFixCallbackStub {
55 public:
56 QuickFixCallbackImpl() = default;
57 virtual ~QuickFixCallbackImpl() = default;
58
OnLoadPatchDone(int32_t resultCode,int32_t recordId)59 void OnLoadPatchDone(int32_t resultCode, int32_t recordId) override
60 {
61 TAG_LOGD(AAFwkTag::TEST, "function called.");
62 }
63
OnUnloadPatchDone(int32_t resultCode,int32_t recordId)64 void OnUnloadPatchDone(int32_t resultCode, int32_t recordId) override
65 {
66 TAG_LOGD(AAFwkTag::TEST, "function called.");
67 }
68
OnReloadPageDone(int32_t resultCode,int32_t recordId)69 void OnReloadPageDone(int32_t resultCode, int32_t recordId) override
70 {
71 TAG_LOGD(AAFwkTag::TEST, "function called.");
72 }
73 };
74
75 class AppMgrProxyTest : public testing::Test {
76 public:
77 static void SetUpTestCase();
78 static void TearDownTestCase();
79 void SetUp() override;
80 void TearDown() override;
81
82 sptr<MockAppMgrService> mockAppMgrService_;
83 sptr<AppMgrProxy> appMgrProxy_;
84 };
85
SetUpTestCase(void)86 void AppMgrProxyTest::SetUpTestCase(void)
87 {}
88
TearDownTestCase(void)89 void AppMgrProxyTest::TearDownTestCase(void)
90 {}
91
SetUp()92 void AppMgrProxyTest::SetUp()
93 {
94 GTEST_LOG_(INFO) << "AppMgrProxyTest::SetUp()";
95
96 mockAppMgrService_ = new MockAppMgrService();
97 appMgrProxy_ = new AppMgrProxy(mockAppMgrService_);
98 }
99
TearDown()100 void AppMgrProxyTest::TearDown()
101 {}
102
103 /**
104 * @tc.name: AppMgrProxy_GetProcessRunningInfosByUserId_0100
105 * @tc.desc: GetProcessRunningInfosByUserId
106 * @tc.type: FUNC
107 * @tc.require: SR000GH1GO
108 */
109 HWTEST_F(AppMgrProxyTest, AppMgrProxy_GetProcessRunningInfosByUserId_0100, TestSize.Level0)
110 {
111 GTEST_LOG_(INFO) << "AppMgrProxy_GetProcessRunningInfosByUserId_0100 start";
112
113 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
114 .Times(1)
115 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
116
117 std::vector<RunningProcessInfo> info;
118 appMgrProxy_->GetProcessRunningInfosByUserId(info, USER_ID);
119
120 EXPECT_EQ(
121 mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::APP_GET_RUNNING_PROCESSES_BY_USER_ID));
122
123 GTEST_LOG_(INFO) << "AppMgrProxy_GetProcessRunningInfosByUserId_0100 end";
124 }
125
126 /**
127 * @tc.name: AppMgrProxy_GetAllRenderProcesses_0100
128 * @tc.desc: GetAllRenderProcesses
129 * @tc.type: FUNC
130 */
131 HWTEST_F(AppMgrProxyTest, AppMgrProxy_GetAllRenderProcesses_0100, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "AppMgrProxy_GetAllRenderProcesses_0100 start";
134
135 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
136 .Times(1)
137 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
138
139 std::vector<RenderProcessInfo> info;
140 appMgrProxy_->GetAllRenderProcesses(info);
141
142 EXPECT_EQ(
143 mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::APP_GET_ALL_RENDER_PROCESSES));
144
145 GTEST_LOG_(INFO) << "AppMgrProxy_GetAllRenderProcesses_0100 end";
146 }
147
148 #ifdef SUPPORT_CHILD_PROCESS
149 /**
150 * @tc.name: AppMgrProxy_GetAllChildrenProcesses_0100
151 * @tc.desc: GetAllChildrenProcesses
152 * @tc.type: FUNC
153 */
154 HWTEST_F(AppMgrProxyTest, AppMgrProxy_GetAllChildrenProcesses_0100, TestSize.Level2)
155 {
156 GTEST_LOG_(INFO) << "AppMgrProxy_GetAllChildrenProcesses_0100 start";
157
158 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
159 .Times(1)
160 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
161
162 std::vector<ChildProcessInfo> info;
163 appMgrProxy_->GetAllChildrenProcesses(info);
164
165 EXPECT_EQ(
166 mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::GET_ALL_CHILDREN_PROCESSES));
167
168 GTEST_LOG_(INFO) << "AppMgrProxy_GetAllChildrenProcesses_0100 end";
169 }
170 #endif // SUPPORT_CHILD_PROCESS
171
172 /**
173 * @tc.name: GetAppRunningStateByBundleName_0100
174 * @tc.desc: Get app running state by bundle name.
175 * @tc.type: FUNC
176 * @tc.require: issueI581VW
177 */
178 HWTEST_F(AppMgrProxyTest, GetAppRunningStateByBundleName_0100, TestSize.Level1)
179 {
180 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
181
182 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
183 .Times(1)
184 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
185
186 std::string bundleName = "testBundleName";
187 appMgrProxy_->GetAppRunningStateByBundleName(bundleName);
188
189 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::GET_APP_RUNNING_STATE));
190
191 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
192 }
193
194 /**
195 * @tc.name: NotifyLoadRepairPatch_0100
196 * @tc.desc: Notify load repair patch.
197 * @tc.type: FUNC
198 * @tc.require: issueI581VW
199 */
200 HWTEST_F(AppMgrProxyTest, NotifyLoadRepairPatch_0100, TestSize.Level2)
201 {
202 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
203
204 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
205 .Times(1)
206 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
207
208 std::string bundleName = "testBundleName";
209 sptr<IQuickFixCallback> callback = new QuickFixCallbackImpl();
210 appMgrProxy_->NotifyLoadRepairPatch(bundleName, callback);
211
212 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_LOAD_REPAIR_PATCH));
213
214 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
215 }
216
217 /**
218 * @tc.name: NotifyHotReloadPage_0100
219 * @tc.desc: Notify ace execute hot reload page.
220 * @tc.type: FUNC
221 * @tc.require: issueI581VW
222 */
223 HWTEST_F(AppMgrProxyTest, NotifyHotReloadPage_0100, TestSize.Level2)
224 {
225 TAG_LOGI(AAFwkTag::TEST, "%{public}s start", __func__);
226
227 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
228 .Times(1)
229 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
230
231 std::string bundleName = "testBundleName";
232 sptr<IQuickFixCallback> callback = new QuickFixCallbackImpl();
233 appMgrProxy_->NotifyHotReloadPage(bundleName, callback);
234
235 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_HOT_RELOAD_PAGE));
236
237 TAG_LOGI(AAFwkTag::TEST, "%{public}s end", __func__);
238 }
239
240 /**
241 * @tc.name: NotifyUnLoadRepairPatch_0100
242 * @tc.desc: Notify unload repair patch.
243 * @tc.type: FUNC
244 * @tc.require: issueI581VW
245 */
246 HWTEST_F(AppMgrProxyTest, NotifyUnLoadRepairPatch_0100, TestSize.Level2)
247 {
248 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
249
250 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
251 .Times(1)
252 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
253
254 std::string bundleName = "testBundleName";
255 sptr<IQuickFixCallback> callback = new QuickFixCallbackImpl();
256 appMgrProxy_->NotifyUnLoadRepairPatch(bundleName, callback);
257
258 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_UNLOAD_REPAIR_PATCH));
259
260 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
261 }
262
263 /**
264 * @tc.name: PreStartNWebSpawnProcess_001
265 * @tc.desc: prestart nwebspawn process.
266 * @tc.type: FUNC
267 * @tc.require: issueI5W4S7
268 */
269 HWTEST_F(AppMgrProxyTest, PreStartNWebSpawnProcess_001, TestSize.Level2)
270 {
271 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
272
273 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
274 .Times(1)
275 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
276
277 appMgrProxy_->PreStartNWebSpawnProcess();
278 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::PRE_START_NWEBSPAWN_PROCESS));
279
280 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
281 }
282
283 /**
284 * @tc.name: GetProcessMemoryByPid_001
285 * @tc.desc: Get memorySize by pid.
286 * @tc.type: FUNC
287 * @tc.require: issueI76JBF
288 */
289 HWTEST_F(AppMgrProxyTest, GetProcessMemoryByPid_001, TestSize.Level1)
290 {
291 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
292
293 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
294 .Times(1)
295 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
296
297 int32_t pid = 0;
298 int32_t memorySize = 0;
299 appMgrProxy_->GetProcessMemoryByPid(pid, memorySize);
300 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::GET_PROCESS_MEMORY_BY_PID));
301
302 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
303 }
304
305 /**
306 * @tc.name: GetRunningProcessInformation_001
307 * @tc.desc: Get application processes information list by bundleName.
308 * @tc.type: FUNC
309 * @tc.require: issueI76JBF
310 */
311 HWTEST_F(AppMgrProxyTest, GetRunningProcessInformation_001, TestSize.Level1)
312 {
313 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
314
315 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
316 .Times(1)
317 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
318
319 std::string bundleName = "testBundleName";
320 int32_t userId = USER_ID;
321 std::vector<RunningProcessInfo> info;
322 appMgrProxy_->GetRunningProcessInformation(bundleName, userId, info);
323 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::GET_PIDS_BY_BUNDLENAME));
324
325 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
326 }
327
328 /**
329 * @tc.name: NotifyAppFault_001
330 * @tc.desc: Notify app fault.
331 * @tc.type: FUNC
332 * @tc.require: issueI79RY8
333 */
334 HWTEST_F(AppMgrProxyTest, NotifyAppFault_001, TestSize.Level1)
335 {
336 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
337 .Times(1)
338 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
339 FaultData faultData;
340 appMgrProxy_->NotifyAppFault(faultData);
341 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_APP_FAULT));
342 }
343
344 /**
345 * @tc.name: NotifyAppFaultBySA_001
346 * @tc.desc: Notify app fault by SA.
347 * @tc.type: FUNC
348 * @tc.require: issueI79RY8
349 */
350 HWTEST_F(AppMgrProxyTest, NotifyAppFaultBySA_001, TestSize.Level1)
351 {
352 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
353 .Times(1)
354 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
355 AppFaultDataBySA faultData;
356 appMgrProxy_->NotifyAppFaultBySA(faultData);
357 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::NOTIFY_APP_FAULT_BY_SA));
358 }
359
360 /**
361 * @tc.name: SetAppFreezeFilter_001
362 * @tc.desc: Set appfreeze filter.
363 * @tc.type: FUNC
364 */
365 HWTEST_F(AppMgrProxyTest, SetAppFreezeFilter_001, TestSize.Level1)
366 {
367 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
368 .Times(1)
369 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
370 int32_t pid = 0; // test value
371 appMgrProxy_->SetAppFreezeFilter(pid);
372 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::SET_APPFREEZE_FILTER));
373 }
374
375 /**
376 * @tc.name: ChangeAppGcState_001
377 * @tc.desc: Change app Gc state.
378 * @tc.type: FUNC
379 * @tc.require: issuesI85VVU
380 */
381 HWTEST_F(AppMgrProxyTest, ChangeAppGcState_001, TestSize.Level1)
382 {
383 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
384 .Times(1)
385 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
386 int32_t pid = 0;
387 int32_t state = 0;
388 appMgrProxy_->ChangeAppGcState(pid, state);
389 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::CHANGE_APP_GC_STATE));
390 }
391
392 /**
393 * @tc.name: ChangeAppGcState_002
394 * @tc.desc: Change app Gc state.
395 * @tc.type: FUNC
396 * @tc.require: issuesI85VVU
397 */
398 HWTEST_F(AppMgrProxyTest, ChangeAppGcState_002, TestSize.Level1)
399 {
400 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
401 .Times(1)
402 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
403 int32_t pid = 0;
404 int32_t state = 0;
405 uint64_t tid = 1;
406 appMgrProxy_->ChangeAppGcState(pid, state, tid);
407 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::CHANGE_APP_GC_STATE));
408 }
409
410 /**
411 * @tc.name: IsApplicationRunning_001
412 * @tc.desc: Send request to query the running status of the application.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(AppMgrProxyTest, IsApplicationRunning_001, TestSize.Level1)
416 {
417 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
418 .Times(1)
419 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
420
421 std::string bundleName = "testBundleName";
422 bool isRunning = false;
423 appMgrProxy_->IsApplicationRunning(bundleName, isRunning);
424 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::IS_APPLICATION_RUNNING));
425 }
426
427 /**
428 * @tc.name: IsAppRunning_001
429 * @tc.desc: Send request to query the running status of the application.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(AppMgrProxyTest, IsAppRunning_001, TestSize.Level1)
433 {
434 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
435 .Times(1)
436 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
437
438 std::string bundleName = "testBundleName";
439 int32_t appCloneIndex = 0;
440 bool isRunning = false;
441
442 appMgrProxy_->IsAppRunning(bundleName, appCloneIndex, isRunning);
443 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::IS_APP_RUNNING));
444 }
445
446 /**
447 * @tc.number: RegisterAbilityForegroundStateObserver_0100
448 * @tc.desc: Verify that the RegisterAbilityForegroundStateObserver function is called normally.
449 * @tc.type: FUNC
450 */
451 HWTEST_F(AppMgrProxyTest, RegisterAbilityForegroundStateObserver_0100, TestSize.Level1)
452 {
453 sptr<IAbilityForegroundStateObserver> observer = new MockAbilityForegroundStateObserverStub();
454 EXPECT_NE(observer->AsObject(), nullptr);
455 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
456 .Times(1)
457 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
458 appMgrProxy_->RegisterAbilityForegroundStateObserver(observer);
459 EXPECT_EQ(mockAppMgrService_->code_,
460 static_cast<uint32_t>(AppMgrInterfaceCode::REGISTER_ABILITY_FOREGROUND_STATE_OBSERVER));
461 }
462
463 /**
464 * @tc.number: RegisterAbilityForegroundStateObserver_0200
465 * @tc.desc: Verify that the RegisterAbilityForegroundStateObserver parameter of the function is null.
466 * @tc.type: FUNC
467 */
468 HWTEST_F(AppMgrProxyTest, RegisterAbilityForegroundStateObserver_0200, TestSize.Level1)
469 {
470 sptr<IAbilityForegroundStateObserver> observer = nullptr;
471 auto result = appMgrProxy_->RegisterAbilityForegroundStateObserver(observer);
472 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
473 }
474
475 /**
476 * @tc.number: UnregisterAbilityForegroundStateObserver_0100
477 * @tc.desc: Verify that the UnregisterAbilityForegroundStateObserver function is called normally.
478 * @tc.type: FUNC
479 */
480 HWTEST_F(AppMgrProxyTest, UnregisterAbilityForegroundStateObserver_0100, TestSize.Level1)
481 {
482 sptr<IAbilityForegroundStateObserver> observer = new MockAbilityForegroundStateObserverStub();
483 EXPECT_NE(observer->AsObject(), nullptr);
484 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
485 .Times(1)
486 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
487 appMgrProxy_->UnregisterAbilityForegroundStateObserver(observer);
488 EXPECT_EQ(mockAppMgrService_->code_,
489 static_cast<uint32_t>(AppMgrInterfaceCode::UNREGISTER_ABILITY_FOREGROUND_STATE_OBSERVER));
490 }
491
492 /**
493 * @tc.number: RegisterAbilityForegroundStateObserver_0200
494 * @tc.desc: Verify that the UnregisterAbilityForegroundStateObserver parameter of the function is null.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(AppMgrProxyTest, UnregisterAbilityForegroundStateObserver_0200, TestSize.Level1)
498 {
499 sptr<IAbilityForegroundStateObserver> observer = nullptr;
500 auto result = appMgrProxy_->UnregisterAbilityForegroundStateObserver(observer);
501 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
502 }
503
504 /**
505 * @tc.name: RegisterAppForegroundStateObserver_0100
506 * @tc.desc: Test when all condition not met.
507 * @tc.type: FUNC
508 */
509 HWTEST_F(AppMgrProxyTest, RegisterAppForegroundStateObserver_0100, TestSize.Level1)
510 {
511 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
512 sptr<IAppForegroundStateObserver> observer = new (std::nothrow) AppForegroundStateObserverMock();
513 auto res = appMgrProxy_->RegisterAppForegroundStateObserver(observer);
514 EXPECT_EQ(res, NO_ERROR);
515 }
516
517 /**
518 * @tc.name: UnregisterAppForegroundStateObserver_0100
519 * @tc.desc: Test when all condition not met.
520 * @tc.type: FUNC
521 */
522 HWTEST_F(AppMgrProxyTest, UnregisterAppForegroundStateObserver_0100, TestSize.Level1)
523 {
524 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
525 sptr<IAppForegroundStateObserver> observer = new (std::nothrow) AppForegroundStateObserverMock();
526 auto res = appMgrProxy_->RegisterAppForegroundStateObserver(observer);
527 EXPECT_EQ(res, NO_ERROR);
528 }
529
530 /**
531 * @tc.name: RegisterRenderStateObserver_0100
532 * @tc.desc: Test registerRenderStateObserversendRequest.
533 * @tc.type: FUNC
534 */
535 HWTEST_F(AppMgrProxyTest, RegisterRenderStateObserver_0100, TestSize.Level1)
536 {
537 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
538 sptr<IRenderStateObserver> observer = new (std::nothrow) RenderStateObserverMock();
539 auto res = appMgrProxy_->RegisterRenderStateObserver(observer);
540 EXPECT_EQ(res, NO_ERROR);
541 }
542
543 /**
544 * @tc.name: UnregisterRenderStateObserver_0100
545 * @tc.desc: Test unregisterRenderStateObserversendRequest.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(AppMgrProxyTest, UnregisterRenderStateObserver_0100, TestSize.Level1)
549 {
550 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
551 sptr<IRenderStateObserver> observer = new (std::nothrow) RenderStateObserverMock();
552 auto res = appMgrProxy_->UnregisterRenderStateObserver(observer);
553 EXPECT_EQ(res, NO_ERROR);
554 }
555
556 /**
557 * @tc.name: UpdateRenderState_0100
558 * @tc.desc: Test updateRenderState sendRequest.
559 * @tc.type: FUNC
560 */
561 HWTEST_F(AppMgrProxyTest, UpdateRenderState_0100, TestSize.Level1)
562 {
563 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
564 pid_t renderPid = 0;
565 int32_t state = 0;
566 auto res = appMgrProxy_->UpdateRenderState(renderPid, state);
567 EXPECT_EQ(res, NO_ERROR);
568 }
569
570 /**
571 * @tc.name: SignRestartAppFlag_0100
572 * @tc.desc: Test SignRestartAppFlag.
573 * @tc.type: FUNC
574 */
575 HWTEST_F(AppMgrProxyTest, SignRestartAppFlag_0100, TestSize.Level1)
576 {
577 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
578 int32_t uid = 0;
579 auto res = appMgrProxy_->SignRestartAppFlag(uid, "");
580 EXPECT_EQ(res, NO_ERROR);
581 }
582
583 /**
584 * @tc.name: NotifyMemorySizeStateChanged_0100
585 * @tc.desc: Test NotifyMemorySizeStateChanged.
586 * @tc.type: FUNC
587 */
588 HWTEST_F(AppMgrProxyTest, NotifyMemorySizeStateChanged_0100, TestSize.Level1)
589 {
590 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
591 int32_t memorySizeState = 1;
592 auto res = appMgrProxy_->NotifyMemorySizeStateChanged(memorySizeState);
593 EXPECT_EQ(res, NO_ERROR);
594 }
595
596 /**
597 * @tc.name: NotifyMemorySizeStateChanged_0200
598 * @tc.desc: Test NotifyMemorySizeStateChanged.
599 * @tc.type: FUNC
600 */
601 HWTEST_F(AppMgrProxyTest, NotifyMemorySizeStateChanged_0200, TestSize.Level1)
602 {
603 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
604 int32_t memorySizeState = 0;
605 auto res = appMgrProxy_->NotifyMemorySizeStateChanged(memorySizeState);
606 EXPECT_EQ(res, NO_ERROR);
607 }
608
609 /**
610 * @tc.name: GetAllUIExtensionRootHostPid_0100
611 * @tc.desc: Get all ui extension root host pid.
612 * @tc.type: FUNC
613 */
614 HWTEST_F(AppMgrProxyTest, GetAllUIExtensionRootHostPid_0100, TestSize.Level1)
615 {
616 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
617 .Times(1)
618 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
619 pid_t pid = 0;
620 std::vector<pid_t> hostPids;
621 auto res = appMgrProxy_->GetAllUIExtensionRootHostPid(pid, hostPids);
622 EXPECT_EQ(res, NO_ERROR);
623 EXPECT_EQ(mockAppMgrService_->code_,
624 static_cast<uint32_t>(AppMgrInterfaceCode::GET_ALL_UI_EXTENSION_ROOT_HOST_PID));
625 }
626
627 /**
628 * @tc.name: GetAllUIExtensionProviderPid_0100
629 * @tc.desc: Get all ui extension provider pid.
630 * @tc.type: FUNC
631 */
632 HWTEST_F(AppMgrProxyTest, GetAllUIExtensionProviderPid_0100, TestSize.Level1)
633 {
634 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
635 .Times(1)
636 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
637 pid_t hostPid = 0;
638 std::vector<pid_t> providerPids;
639 auto res = appMgrProxy_->GetAllUIExtensionProviderPid(hostPid, providerPids);
640 EXPECT_EQ(res, NO_ERROR);
641 EXPECT_EQ(mockAppMgrService_->code_,
642 static_cast<uint32_t>(AppMgrInterfaceCode::GET_ALL_UI_EXTENSION_PROVIDER_PID));
643 }
644
645 /**
646 * @tc.name: PreloadApplication_0100
647 * @tc.desc: Preload application.
648 * @tc.type: FUNC
649 * @tc.Function: PreloadApplication
650 * @tc.SubFunction: NA
651 * @tc.EnvConditions: NA
652 */
653 HWTEST_F(AppMgrProxyTest, PreloadApplication_0100, TestSize.Level1)
654 {
655 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
656 .Times(1)
657 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
658
659 std::string bundleName = "com.acts.preloadtest";
660 int32_t userId = 100;
661 PreloadMode preloadMode = PreloadMode::PRE_MAKE;
662 int32_t appIndex = 0;
663 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
664 EXPECT_EQ(ret, NO_ERROR);
665 EXPECT_EQ(mockAppMgrService_->code_,
666 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
667 }
668
669 /**
670 * @tc.name: PreloadApplication_0200
671 * @tc.desc: Preload application.
672 * @tc.type: FUNC
673 * @tc.Function: PreloadApplication
674 * @tc.SubFunction: NA
675 * @tc.EnvConditions: NA
676 */
677 HWTEST_F(AppMgrProxyTest, PreloadApplication_0200, TestSize.Level1)
678 {
679 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
680 .Times(1)
681 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
682
683 std::string bundleName = "";
684 int32_t userId = 100;
685 PreloadMode preloadMode = PreloadMode::PRE_MAKE;
686 int32_t appIndex = 0;
687 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
688 EXPECT_EQ(ret, NO_ERROR);
689 EXPECT_EQ(mockAppMgrService_->code_,
690 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
691 }
692
693 /**
694 * @tc.name: PreloadApplication_0300
695 * @tc.desc: Preload application.
696 * @tc.type: FUNC
697 * @tc.Function: PreloadApplication
698 * @tc.SubFunction: NA
699 * @tc.EnvConditions: NA
700 */
701 HWTEST_F(AppMgrProxyTest, PreloadApplication_0300, TestSize.Level1)
702 {
703 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
704 .Times(1)
705 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
706
707 std::string bundleName = "com.acts.preloadtest";
708 int32_t userId = 100;
709 PreloadMode preloadMode = PreloadMode::PRESS_DOWN;
710 int32_t appIndex = 0;
711 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
712 EXPECT_EQ(ret, NO_ERROR);
713 EXPECT_EQ(mockAppMgrService_->code_,
714 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
715 }
716
717 /**
718 * @tc.name: PreloadApplication_0400
719 * @tc.desc: Preload application.
720 * @tc.type: FUNC
721 * @tc.Function: PreloadApplication
722 * @tc.SubFunction: NA
723 * @tc.EnvConditions: NA
724 */
725 HWTEST_F(AppMgrProxyTest, PreloadApplication_0400, TestSize.Level1)
726 {
727 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
728 .Times(1)
729 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
730
731 std::string bundleName = "";
732 int32_t userId = 100;
733 PreloadMode preloadMode = PreloadMode::PRESS_DOWN;
734 int32_t appIndex = 0;
735 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
736 EXPECT_EQ(ret, NO_ERROR);
737 EXPECT_EQ(mockAppMgrService_->code_,
738 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
739 }
740
741 /**
742 * @tc.name: PreloadApplication_0500
743 * @tc.desc: Preload application.
744 * @tc.type: FUNC
745 * @tc.Function: PreloadApplication
746 * @tc.SubFunction: NA
747 * @tc.EnvConditions: NA
748 */
749 HWTEST_F(AppMgrProxyTest, PreloadApplication_0500, TestSize.Level1)
750 {
751 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
752 .Times(1)
753 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
754
755 std::string bundleName = "com.acts.preloadtest";
756 int32_t userId = -1;
757 PreloadMode preloadMode = PreloadMode::PRE_MAKE;
758 int32_t appIndex = 0;
759 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
760 EXPECT_EQ(ret, NO_ERROR);
761 EXPECT_EQ(mockAppMgrService_->code_,
762 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
763 }
764
765 /**
766 * @tc.name: PreloadApplication_0600
767 * @tc.desc: Preload application.
768 * @tc.type: FUNC
769 * @tc.Function: PreloadApplication
770 * @tc.SubFunction: NA
771 * @tc.EnvConditions: NA
772 */
773 HWTEST_F(AppMgrProxyTest, PreloadApplication_0600, TestSize.Level1)
774 {
775 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
776 .Times(1)
777 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
778
779 std::string bundleName = "";
780 int32_t userId = -1;
781 PreloadMode preloadMode = PreloadMode::PRE_MAKE;
782 int32_t appIndex = 0;
783 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
784 EXPECT_EQ(ret, NO_ERROR);
785 EXPECT_EQ(mockAppMgrService_->code_,
786 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
787 }
788
789 /**
790 * @tc.name: PreloadApplication_0700
791 * @tc.desc: Preload application.
792 * @tc.type: FUNC
793 * @tc.Function: PreloadApplication
794 * @tc.SubFunction: NA
795 * @tc.EnvConditions: NA
796 */
797 HWTEST_F(AppMgrProxyTest, PreloadApplication_0700, TestSize.Level1)
798 {
799 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
800 .Times(1)
801 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
802
803 std::string bundleName = "com.acts.preloadtest";
804 int32_t userId = -1;
805 PreloadMode preloadMode = PreloadMode::PRESS_DOWN;
806 int32_t appIndex = 0;
807 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
808 EXPECT_EQ(ret, NO_ERROR);
809 EXPECT_EQ(mockAppMgrService_->code_,
810 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
811 }
812
813 /**
814 * @tc.name: PreloadApplication_0800
815 * @tc.desc: Preload application.
816 * @tc.type: FUNC
817 * @tc.Function: PreloadApplication
818 * @tc.SubFunction: NA
819 * @tc.EnvConditions: NA
820 */
821 HWTEST_F(AppMgrProxyTest, PreloadApplication_0800, TestSize.Level1)
822 {
823 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
824 .Times(1)
825 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
826
827 std::string bundleName = "";
828 int32_t userId = -1;
829 PreloadMode preloadMode = PreloadMode::PRESS_DOWN;
830 int32_t appIndex = 0;
831 auto ret = appMgrProxy_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
832 EXPECT_EQ(ret, NO_ERROR);
833 EXPECT_EQ(mockAppMgrService_->code_,
834 static_cast<uint32_t>(AppMgrInterfaceCode::PRELOAD_APPLICATION));
835 }
836
837 /**
838 * @tc.name: PreloadModuleFinished_0001
839 * @tc.desc: Preload application.
840 * @tc.type: FUNC
841 * @tc.Function: PreloadModuleFinished
842 * @tc.SubFunction: NA
843 * @tc.EnvConditions: NA
844 */
845 HWTEST_F(AppMgrProxyTest, PreloadModuleFinished_0001, TestSize.Level1)
846 {
847 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
848 .Times(1)
849 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
850
851 int32_t recordId = 0;
852 appMgrProxy_->PreloadModuleFinished(recordId);
853 }
854
855 /**
856 * @tc.name: SetSupportedProcessCacheSelf_001
857 * @tc.desc: The application sets itself whether or not to support process cache.
858 * @tc.type: FUNC
859 */
860 HWTEST_F(AppMgrProxyTest, SetSupportedProcessCacheSelf_001, TestSize.Level2)
861 {
862 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
863
864 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
865 .Times(1)
866 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
867 bool isSupported = false;
868 appMgrProxy_->SetSupportedProcessCacheSelf(isSupported);
869 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::SET_SUPPORTED_PROCESS_CACHE_SELF));
870
871 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
872 }
873
874 /**
875 * @tc.name: GetRunningMultiAppInfoByBundleName_001
876 * @tc.desc: Get multiApp information by bundleName.
877 * @tc.type: FUNC
878 * @tc.require: issueI9HMAO
879 */
880 HWTEST_F(AppMgrProxyTest, GetRunningMultiAppInfoByBundleName_001, TestSize.Level1)
881 {
882 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
883
884 MessageParcel data;
885 MessageParcel reply;
886 MessageOption option;
887
888 data.WriteInterfaceToken(AppMgrStub::GetDescriptor());
889 std::string bundleName = "testBundleName";
890 data.WriteString(bundleName);
891
892 EXPECT_CALL(*mockAppMgrService_, GetRunningMultiAppInfoByBundleName(_, _)).Times(1);
893
894 auto result = mockAppMgrService_->OnRemoteRequest(
895 static_cast<uint32_t>(AppMgrInterfaceCode::GET_RUNNING_MULTIAPP_INFO_BY_BUNDLENAME), data, reply, option);
896 EXPECT_EQ(result, NO_ERROR);
897
898 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
899 }
900
901 /**
902 * @tc.name: GetAllRunningInstanceKeysBySelf_001
903 * @tc.desc: GetAllRunningInstanceKeysBySelf.
904 * @tc.type: FUNC
905 * @tc.require: issueI9HMAO
906 */
907 HWTEST_F(AppMgrProxyTest, GetAllRunningInstanceKeysBySelf_001, TestSize.Level1)
908 {
909 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
910
911 MessageParcel data;
912 MessageParcel reply;
913 MessageOption option;
914
915 data.WriteInterfaceToken(AppMgrStub::GetDescriptor());
916
917 EXPECT_CALL(*mockAppMgrService_, GetAllRunningInstanceKeysBySelf(_)).Times(1);
918
919 auto result = mockAppMgrService_->OnRemoteRequest(
920 static_cast<uint32_t>(AppMgrInterfaceCode::GET_All_RUNNING_INSTANCE_KEYS_BY_SELF), data, reply, option);
921 EXPECT_EQ(result, NO_ERROR);
922
923 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
924 }
925
926 /**
927 * @tc.name: GetAllRunningInstanceKeysByBundleName_001
928 * @tc.desc: GetAllRunningInstanceKeysByBundleName.
929 * @tc.type: FUNC
930 * @tc.require: issueI9HMAO
931 */
932 HWTEST_F(AppMgrProxyTest, GetAllRunningInstanceKeysByBundleName_001, TestSize.Level1)
933 {
934 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
935
936 MessageParcel data;
937 MessageParcel reply;
938 MessageOption option;
939
940 data.WriteInterfaceToken(AppMgrStub::GetDescriptor());
941 std::string bundleName = "testBundleName";
942 data.WriteString(bundleName);
943 int32_t userId = -1;
944 data.WriteInt32(userId);
945
946 EXPECT_CALL(*mockAppMgrService_, GetAllRunningInstanceKeysByBundleName(_, _, _)).Times(1);
947
948 auto result = mockAppMgrService_->OnRemoteRequest(
949 static_cast<uint32_t>(AppMgrInterfaceCode::GET_All_RUNNING_INSTANCE_KEYS_BY_BUNDLENAME), data, reply, option);
950 EXPECT_EQ(result, NO_ERROR);
951
952 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
953 }
954
955 /**
956 * @tc.name: GetSupportedProcessCachePids_001
957 * @tc.desc: Get pids of processes which belong to specific bundle name and support process cache feature.
958 * @tc.type: FUNC
959 * @tc.require: issueIAGZ7H
960 */
961 HWTEST_F(AppMgrProxyTest, GetSupportedProcessCachePids_001, TestSize.Level2)
962 {
963 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
964
965 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
966 .Times(1)
967 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
968
969 std::string bundleName = "testBundleName";
970 std::vector<int32_t> pidList;
971 appMgrProxy_->GetSupportedProcessCachePids(bundleName, pidList);
972 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::GET_SUPPORTED_PROCESS_CACHE_PIDS));
973
974 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
975 }
976
977 /**
978 * @tc.name: UpdateConfigurationForBackgroundApp_001
979 * @tc.desc: UpdateConfigurationForBackgroundApp.
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(AppMgrProxyTest, UpdateConfigurationForBackgroundApp_001, TestSize.Level2)
984 {
985 TAG_LOGI(AAFwkTag::TEST, "%{public}s start.", __func__);
986
987 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
988 .Times(1)
989 .WillOnce(Invoke(mockAppMgrService_.GetRefPtr(), &MockAppMgrService::InvokeSendRequest));
990
991 std::vector<BackgroundAppInfo> appInfos;
992 ConfigurationPolicy policy;
993 int32_t userId = -1;
994
995 auto ret = appMgrProxy_->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
996 if (appInfos.size() == 0 || appInfos.size() > MAX_BACKGROUND_APP_COUNT) {
997 EXPECT_EQ(ret, ERR_INVALID_DATA);
998 }
999 BackgroundAppInfo info;
1000 appInfos.push_back(info);
1001 appMgrProxy_->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
1002 EXPECT_EQ(mockAppMgrService_->code_, static_cast<uint32_t>(AppMgrInterfaceCode::UPDATE_CONFIGURATION_POLICY));
1003
1004 TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__);
1005 }
1006
1007 /**
1008 * @tc.name: IsProcessCacheSupported_0100
1009 * @tc.desc: Test IsProcessCacheSupported.
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(AppMgrProxyTest, IsProcessCacheSupported_0100, TestSize.Level1)
1013 {
1014 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
1015 int32_t pid = 1;
1016 bool isSupport = false;
1017 auto ret = appMgrProxy_->IsProcessCacheSupported(pid, isSupport);
1018 EXPECT_EQ(ret, NO_ERROR);
1019 }
1020
1021 /**
1022 * @tc.name: SetProcessCacheEnable_0100
1023 * @tc.desc: Test SetProcessCacheEnable.
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(AppMgrProxyTest, SetProcessCacheEnable_0100, TestSize.Level1)
1027 {
1028 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _)).Times(1);
1029 int32_t pid = 1;
1030 bool enable = false;
1031 auto ret = appMgrProxy_->SetProcessCacheEnable(pid, enable);
1032 EXPECT_EQ(ret, NO_ERROR);
1033 }
1034
1035 /**
1036 * @tc.name: QueryRunningSharedBundles_0100
1037 * @tc.desc: Test QueryRunningSharedBundles.
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(AppMgrProxyTest, QueryRunningSharedBundles_0100, TestSize.Level1)
1041 {
1042 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0100 start.");
1043 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
1044 .Times(1)
1045 .WillOnce(Return(ERR_INVALID_VALUE));
1046 pid_t pid = 1;
1047 std::map<std::string, uint32_t> sharedBundles;
1048 auto ret = appMgrProxy_->QueryRunningSharedBundles(pid, sharedBundles);
1049 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1050 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0100 end.");
1051 }
1052
1053 /**
1054 * @tc.name: QueryRunningSharedBundles_0200
1055 * @tc.desc: Test QueryRunningSharedBundles.
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F(AppMgrProxyTest, QueryRunningSharedBundles_0200, TestSize.Level1)
1059 {
1060 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0100 start.");
1061 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
1062 .Times(1)
__anon1327dc780202(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 1063 .WillOnce([](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) {
1064 reply.WriteInt32(ERR_INVALID_VALUE);
1065 return NO_ERROR;
1066 });
1067
1068 pid_t pid = 1;
1069 std::map<std::string, uint32_t> sharedBundles;
1070 auto ret = appMgrProxy_->QueryRunningSharedBundles(pid, sharedBundles);
1071 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1072 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0200 end.");
1073 }
1074
1075 /**
1076 * @tc.name: QueryRunningSharedBundles_0300
1077 * @tc.desc: Test QueryRunningSharedBundles.
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(AppMgrProxyTest, QueryRunningSharedBundles_0300, TestSize.Level1)
1081 {
1082 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0100 start.");
1083 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
1084 .Times(1)
__anon1327dc780302(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 1085 .WillOnce([](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) {
1086 reply.WriteInt32(ERR_OK);
1087 reply.WriteInt32(1001);
1088 return NO_ERROR;
1089 });
1090
1091 pid_t pid = 1;
1092 std::map<std::string, uint32_t> sharedBundles;
1093 auto ret = appMgrProxy_->QueryRunningSharedBundles(pid, sharedBundles);
1094 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1095 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0300 end.");
1096 }
1097
1098 /**
1099 * @tc.name: QueryRunningSharedBundles_0400
1100 * @tc.desc: Test QueryRunningSharedBundles.
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(AppMgrProxyTest, QueryRunningSharedBundles_0400, TestSize.Level1)
1104 {
1105 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0400 start.");
1106 EXPECT_CALL(*mockAppMgrService_, SendRequest(_, _, _, _))
1107 .Times(1)
__anon1327dc780402(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) 1108 .WillOnce([](uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) {
1109 reply.WriteInt32(ERR_OK);
1110 reply.WriteInt32(1);
1111 reply.WriteString("com.test.example");
1112 reply.WriteUint32(10000);
1113 return NO_ERROR;
1114 });
1115
1116 pid_t pid = 1;
1117 std::map<std::string, uint32_t> sharedBundles;
1118 auto ret = appMgrProxy_->QueryRunningSharedBundles(pid, sharedBundles);
1119 EXPECT_EQ(ret, ERR_OK);
1120 EXPECT_FALSE(sharedBundles.empty());
1121 TAG_LOGI(AAFwkTag::TEST, "QueryRunningSharedBundles_0300 end.");
1122 }
1123 } // namespace AppExecFwk
1124 } // namespace OHOS
1125