1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
16
17 #include "ability_manager_errors.h"
18 #include "ability_manager_proxy.h"
19 #include "ability_manager_stub_mock.h"
20 #include "ability_record.h"
21 #include "ability_scheduler.h"
22 #include "ability_scheduler_mock.h"
23 #include "app_debug_listener_stub_mock.h"
24 #include "hilog_tag_wrapper.h"
25 #include "mission_snapshot.h"
26 #include "mock_ability_connect_callback.h"
27 #include "mock_ability_token.h"
28 #include "want_sender_info.h"
29
30 using namespace testing::ext;
31 using namespace testing;
32 using namespace OHOS::AppExecFwk;
33 namespace OHOS {
34 namespace AAFwk {
35 namespace {
36 const int USER_ID = 100;
37 constexpr int RESULT_CODE = 1;
38 } // namespace
39 class AbilityManagerProxyTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 std::shared_ptr<AbilityManagerProxy> proxy_{ nullptr };
46 sptr<AbilityManagerStubMock> mock_{ nullptr };
47 };
SetUpTestCase(void)48 void AbilityManagerProxyTest::SetUpTestCase(void)
49 {}
TearDownTestCase(void)50 void AbilityManagerProxyTest::TearDownTestCase(void)
51 {}
SetUp()52 void AbilityManagerProxyTest::SetUp()
53 {
54 mock_ = new AbilityManagerStubMock();
55 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
56 }
57
TearDown()58 void AbilityManagerProxyTest::TearDown()
59 {}
60
61 /**
62 * @tc.name: AbilityManagerProxy_StartUIAbilityBySCB_0100
63 * @tc.desc: StartUIAbilityBySCB
64 * @tc.type: FUNC
65 */
66 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUIAbilityBySCB_0100, TestSize.Level1)
67 {
68 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StartUIAbilityBySCB_0100 start");
69
70 sptr<SessionInfo> sessionInfo = nullptr;
71 bool isColdStart = false;
72 uint32_t sceneFlag = 0;
73
74 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
75 EXPECT_EQ(proxy_->StartUIAbilityBySCB(sessionInfo, isColdStart, sceneFlag), INVALID_PARAMETERS_ERR);
76
77 sessionInfo = sptr<SessionInfo>::MakeSptr();
78 ASSERT_NE(sessionInfo, nullptr);
79 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
80 EXPECT_EQ(proxy_->StartUIAbilityBySCB(sessionInfo, isColdStart, sceneFlag), NO_ERROR);
81
82 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StartUIAbilityBySCB_0100 end");
83 }
84
85 /**
86 * @tc.name: AbilityManagerProxy_StopExtensionAbility_0100
87 * @tc.desc: StopExtensionAbility
88 * @tc.type: FUNC
89 */
90 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopExtensionAbility_0100, TestSize.Level1)
91 {
92 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StopExtensionAbility_0100 start");
93
94 Want want;
95 int32_t userId = USER_ID;
96 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::FORM;
97 OHOS::sptr<IRemoteObject> callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
98 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
99 EXPECT_EQ(proxy_->StopExtensionAbility(want, callerToken, userId, extensionType), INVALID_PARAMETERS_ERR);
100
101 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StopExtensionAbility_0100 end");
102 }
103
104 /**
105 * @tc.name: AbilityManagerProxy_TerminateAbility_0100
106 * @tc.desc: TerminateAbility
107 * @tc.type: FUNC
108 */
109 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_TerminateAbility_0100, TestSize.Level1)
110 {
111 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateAbility_0100 start");
112
113 int resultCode = RESULT_CODE;
114 Want resultWant;
115 bool flag = false;
116 sptr<IRemoteObject> token = nullptr;
117
118 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
119 EXPECT_EQ(proxy_->TerminateAbility(token, resultCode, &resultWant, flag), INVALID_PARAMETERS_ERR);
120
121 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateAbility_0100 end");
122 }
123
124 /**
125 * @tc.name: AbilityManagerProxy_BackToCallerAbilityWithResult_0100
126 * @tc.desc: BackToCallerAbilityWithResult
127 * @tc.type: FUNC
128 */
129 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_BackToCallerAbilityWithResult_0100, TestSize.Level1)
130 {
131 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_BackToCallerAbilityWithResult_0100 start");
132
133 int resultCode = RESULT_CODE;
134 Want resultWant;
135 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
136 int64_t callerRequestCode = 0;
137
138 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
139 EXPECT_EQ(proxy_->BackToCallerAbilityWithResult(token, resultCode, &resultWant, callerRequestCode),
140 INVALID_PARAMETERS_ERR);
141
142 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
143 EXPECT_EQ(proxy_->BackToCallerAbilityWithResult(token, resultCode, &resultWant, callerRequestCode),
144 NO_ERROR);
145
146 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_BackToCallerAbilityWithResult_0100 end");
147 }
148
149 /**
150 * @tc.name: AbilityManagerProxy_TerminateUIServiceExtensionAbility_0100
151 * @tc.desc: TerminateUIServiceExtensionAbility
152 * @tc.type: FUNC
153 */
154 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_TerminateUIServiceExtensionAbility_0100, TestSize.Level1)
155 {
156 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateUIServiceExtensionAbility_0100 start");
157
158 sptr<IRemoteObject> token = nullptr;
159
160 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
161 EXPECT_EQ(proxy_->TerminateUIServiceExtensionAbility(token), INVALID_PARAMETERS_ERR);
162
163 token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
164 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
165 EXPECT_EQ(proxy_->TerminateUIServiceExtensionAbility(token), NO_ERROR);
166
167 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateUIServiceExtensionAbility_0100 end");
168 }
169
170 /**
171 * @tc.name: AbilityManagerProxy_TerminateUIExtensionAbility_0100
172 * @tc.desc: TerminateUIExtensionAbility
173 * @tc.type: FUNC
174 */
175 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_TerminateUIExtensionAbility_0100, TestSize.Level1)
176 {
177 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateUIExtensionAbility_0100 start");
178
179 sptr<SessionInfo> extensionSessionInfo = nullptr;
180 Want resultWant;
181 int resultCode = RESULT_CODE;
182
183 extensionSessionInfo = sptr<SessionInfo>::MakeSptr();
184 ASSERT_NE(extensionSessionInfo, nullptr);
185 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
186 EXPECT_EQ(proxy_->TerminateUIExtensionAbility(extensionSessionInfo, resultCode, &resultWant), NO_ERROR);
187
188 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_TerminateUIExtensionAbility_0100 end");
189 }
190
191 /**
192 * @tc.name: AbilityManagerProxy_CloseUIExtensionAbilityBySCB_0100
193 * @tc.desc: TerminateUIExtensionAbility
194 * @tc.type: FUNC
195 */
196 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CloseUIExtensionAbilityBySCB_0100, TestSize.Level1)
197 {
198 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CloseUIExtensionAbilityBySCB_0100 start");
199
200 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
201
202 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
203 EXPECT_EQ(proxy_->CloseUIExtensionAbilityBySCB(token), INVALID_PARAMETERS_ERR);
204
205 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
206 EXPECT_EQ(proxy_->CloseUIExtensionAbilityBySCB(token), NO_ERROR);
207
208 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CloseUIExtensionAbilityBySCB_0100 end");
209 }
210
211 /**
212 * @tc.name: AbilityManagerProxy_CloseUIAbilityBySCB_0100
213 * @tc.desc: CloseUIAbilityBySCB
214 * @tc.type: FUNC
215 */
216 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CloseUIAbilityBySCB_0100, TestSize.Level1)
217 {
218 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CloseUIAbilityBySCB_0100 start");
219
220 sptr<SessionInfo> sessionInfo = nullptr;
221 bool isUserRequestedExit = false;
222 uint32_t sceneFlag = 0;
223
224 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
225 EXPECT_EQ(proxy_->CloseUIAbilityBySCB(sessionInfo, isUserRequestedExit, sceneFlag), INVALID_PARAMETERS_ERR);
226
227 sessionInfo = sptr<SessionInfo>::MakeSptr();
228 ASSERT_NE(sessionInfo, nullptr);
229 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
230 EXPECT_EQ(proxy_->CloseUIAbilityBySCB(sessionInfo, isUserRequestedExit, sceneFlag), NO_ERROR);
231
232 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CloseUIAbilityBySCB_0100 end");
233 }
234
235 /**
236 * @tc.name: AbilityManagerProxy_SendResultToAbility_0100
237 * @tc.desc: SendResultToAbility
238 * @tc.type: FUNC
239 */
240 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendResultToAbility_0100, TestSize.Level1)
241 {
242 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SendResultToAbility_0100 start");
243
244 int32_t requestCode = 0;
245 int32_t resultCode = RESULT_CODE;
246 Want resultWant;
247
248 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
249 EXPECT_EQ(proxy_->SendResultToAbility(requestCode, resultCode, resultWant), INVALID_PARAMETERS_ERR);
250
251 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
252 EXPECT_EQ(proxy_->SendResultToAbility(requestCode, resultCode, resultWant), NO_ERROR);
253
254 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SendResultToAbility_0100 end");
255 }
256
257 /**
258 * @tc.name: AbilityManagerProxy_MoveAbilityToBackground_0100
259 * @tc.desc: MoveAbilityToBackground
260 * @tc.type: FUNC
261 */
262 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveAbilityToBackground_0100, TestSize.Level1)
263 {
264 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MoveAbilityToBackground_0100 start");
265
266 sptr<IRemoteObject> token = nullptr;
267
268 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
269 EXPECT_EQ(proxy_->MoveAbilityToBackground(token), INVALID_PARAMETERS_ERR);
270
271 token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
272 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
273 EXPECT_EQ(proxy_->MoveAbilityToBackground(token), NO_ERROR);
274
275 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MoveAbilityToBackground_0100 end");
276 }
277
278 /**
279 * @tc.name: AbilityManagerProxy_MoveUIAbilityToBackground_0100
280 * @tc.desc: MoveUIAbilityToBackground
281 * @tc.type: FUNC
282 */
283 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveUIAbilityToBackground_0100, TestSize.Level1)
284 {
285 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MoveUIAbilityToBackground_0100 start");
286
287 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
288 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
289 EXPECT_EQ(proxy_->MoveUIAbilityToBackground(token), INVALID_PARAMETERS_ERR);
290
291 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
292 EXPECT_EQ(proxy_->MoveUIAbilityToBackground(token), NO_ERROR);
293
294 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MoveUIAbilityToBackground_0100 end");
295 }
296
297 /**
298 * @tc.name: AbilityManagerProxy_MinimizeAbility_0100
299 * @tc.desc: MinimizeAbility
300 * @tc.type: FUNC
301 */
302 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MinimizeAbility_0100, TestSize.Level1)
303 {
304 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeAbility_0100 start");
305
306 bool fromUser = false;
307 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
308
309 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
310 EXPECT_EQ(proxy_->MinimizeAbility(token, fromUser), INVALID_PARAMETERS_ERR);
311
312 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
313 EXPECT_EQ(proxy_->MinimizeAbility(token, fromUser), NO_ERROR);
314
315 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeAbility_0100 end");
316 }
317
318 /**
319 * @tc.name: AbilityManagerProxy_MinimizeUIExtensionAbility_0100
320 * @tc.desc: MinimizeUIExtensionAbility
321 * @tc.type: FUNC
322 */
323 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MinimizeUIExtensionAbility_0100, TestSize.Level1)
324 {
325 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeUIExtensionAbility_0100 start");
326
327 sptr<SessionInfo> sessionInfo = sptr<SessionInfo>::MakeSptr();
328 bool fromUser = false;
329
330 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
331 EXPECT_EQ(proxy_->MinimizeUIExtensionAbility(sessionInfo, fromUser), INVALID_PARAMETERS_ERR);
332
333 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
334 EXPECT_EQ(proxy_->MinimizeUIExtensionAbility(sessionInfo, fromUser), NO_ERROR);
335
336 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeUIExtensionAbility_0100 end");
337 }
338
339 /**
340 * @tc.name: AbilityManagerProxy_MinimizeUIAbilityBySCB_0100
341 * @tc.desc: MinimizeUIAbilityBySCB
342 * @tc.type: FUNC
343 */
344 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MinimizeUIAbilityBySCB_0100, TestSize.Level1)
345 {
346 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeUIAbilityBySCB_0100 start");
347
348 sptr<SessionInfo> sessionInfo = nullptr;
349 bool fromUser = false;
350 uint32_t sceneFlag = 0;
351
352 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
353 EXPECT_EQ(proxy_->MinimizeUIAbilityBySCB(sessionInfo, fromUser, sceneFlag), INVALID_PARAMETERS_ERR);
354
355 sessionInfo = sptr<SessionInfo>::MakeSptr();
356 ASSERT_NE(sessionInfo, nullptr);
357 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
358 EXPECT_EQ(proxy_->MinimizeUIAbilityBySCB(sessionInfo, fromUser, sceneFlag), NO_ERROR);
359
360 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_MinimizeUIAbilityBySCB_0100 end");
361 }
362
363 /**
364 * @tc.name: AbilityManagerProxy_ConnectUIExtensionAbility_0100
365 * @tc.desc: ConnectUIExtensionAbility
366 * @tc.type: FUNC
367 */
368 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ConnectUIExtensionAbility_0100, TestSize.Level1)
369 {
370 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ConnectUIExtensionAbility_0100 start");
371
372 Want want;
373 int32_t userId = USER_ID;
374 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
375 ASSERT_NE(connect, nullptr);
376 sptr<SessionInfo> sessionInfo = sptr<SessionInfo>::MakeSptr();
377 ASSERT_NE(sessionInfo, nullptr);
378 sptr<UIExtensionAbilityConnectInfo> connectInfo = sptr<UIExtensionAbilityConnectInfo>::MakeSptr();
379 ASSERT_NE(connectInfo, nullptr);
380
381 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
382 EXPECT_EQ(proxy_->ConnectUIExtensionAbility(want, connect, sessionInfo, userId, connectInfo),
383 INVALID_PARAMETERS_ERR);
384
385 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
386 EXPECT_EQ(proxy_->ConnectUIExtensionAbility(want, connect, sessionInfo, userId, connectInfo), NO_ERROR);
387
388 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ConnectUIExtensionAbility_0100 end");
389 }
390
391 /**
392 * @tc.name: AbilityManagerProxy_GetAbilityRunningInfos_0100
393 * @tc.desc: GetAbilityRunningInfos
394 * @tc.type: FUNC
395 */
396 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetAbilityRunningInfos_0100, TestSize.Level1)
397 {
398 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetAbilityRunningInfos_0100 start");
399
400 std::vector<AbilityRunningInfo> info;
401
402 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
403 EXPECT_EQ(proxy_->GetAbilityRunningInfos(info), INVALID_PARAMETERS_ERR);
404
405 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
406 EXPECT_EQ(proxy_->GetAbilityRunningInfos(info), NO_ERROR);
407
408 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetAbilityRunningInfos_0100 end");
409 }
410
411 /**
412 * @tc.name: AbilityManagerProxy_GetExtensionRunningInfos_0100
413 * @tc.desc: GetExtensionRunningInfos
414 * @tc.type: FUNC
415 */
416 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetExtensionRunningInfos_0100, TestSize.Level1)
417 {
418 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetExtensionRunningInfos_0100 start");
419
420 int upperLimit = 0;
421 std::vector<ExtensionRunningInfo> info;
422
423 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
424 EXPECT_EQ(proxy_->GetExtensionRunningInfos(upperLimit, info), INVALID_PARAMETERS_ERR);
425
426 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
427 EXPECT_EQ(proxy_->GetExtensionRunningInfos(upperLimit, info), NO_ERROR);
428
429 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetExtensionRunningInfos_0100 end");
430 }
431
432 /**
433 * @tc.name: AbilityManagerProxy_GetProcessRunningInfos_0100
434 * @tc.desc: GetProcessRunningInfos
435 * @tc.type: FUNC
436 */
437 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetProcessRunningInfos_0100, TestSize.Level1)
438 {
439 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetProcessRunningInfos_0100 start");
440
441 std::vector<AppExecFwk::RunningProcessInfo> info;
442
443 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
444 EXPECT_EQ(proxy_->GetProcessRunningInfos(info), INVALID_PARAMETERS_ERR);
445
446 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
447 EXPECT_EQ(proxy_->GetProcessRunningInfos(info), NO_ERROR);
448
449 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetProcessRunningInfos_0100 end");
450 }
451
452 /**
453 * @tc.name: AbilityManagerProxy_IsRunningInStabilityTest_0100
454 * @tc.desc: IsRunningInStabilityTest
455 * @tc.type: FUNC
456 */
457 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsRunningInStabilityTest_0100, TestSize.Level1)
458 {
459 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_IsRunningInStabilityTest_0100 start");
460
461 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
462 EXPECT_EQ(proxy_->IsRunningInStabilityTest(), false);
463
464 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_IsRunningInStabilityTest_0100 end");
465 }
466
467 /**
468 * @tc.name: AbilityManagerProxy_GetMissionSnapshot_0100
469 * @tc.desc: GetMissionSnapshot
470 * @tc.type: FUNC
471 */
472 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetMissionSnapshot_0100, TestSize.Level1)
473 {
474 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetMissionSnapshot_0100 start");
475
476 std::string deviceId = "deviceId";
477 int32_t missionId = 0;
478 MissionSnapshot snapshot;
479 bool isLowResolution = false;
480 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
481 EXPECT_EQ(proxy_->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution), INVALID_PARAMETERS_ERR);
482
483 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetMissionSnapshot_0100 end");
484 }
485
486 /**
487 * @tc.name: AbilityManagerProxy_FinishUserTest_0100
488 * @tc.desc: FinishUserTest
489 * @tc.type: FUNC
490 */
491 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_FinishUserTest_0100, TestSize.Level1)
492 {
493 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_FinishUserTest_0100 start");
494
495 std::string msg = "msg";
496 int64_t resultCode = 0;
497 std::string bundleName = "bundleName";
498
499 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
500 EXPECT_EQ(proxy_->FinishUserTest(msg, resultCode, bundleName), INVALID_PARAMETERS_ERR);
501
502 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_FinishUserTest_0100 end");
503 }
504
505 /**
506 * @tc.name: AbilityManagerProxy_GetTopAbility_0100
507 * @tc.desc: GetTopAbility
508 * @tc.type: FUNC
509 */
510 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetTopAbility_0100, TestSize.Level1)
511 {
512 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetTopAbility_0100 start");
513
514 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
515
516 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
517 EXPECT_EQ(proxy_->GetTopAbility(token), INVALID_PARAMETERS_ERR);
518
519 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetTopAbility_0100 end");
520 }
521
522 /**
523 * @tc.name: AbilityManagerProxy_CheckUIExtensionIsFocused_0100
524 * @tc.desc: CheckUIExtensionIsFocused
525 * @tc.type: FUNC
526 */
527 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CheckUIExtensionIsFocused_0100, TestSize.Level1)
528 {
529 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CheckUIExtensionIsFocused_0100 start");
530
531 uint32_t uiExtensionTokenId = 0;
532 bool isFocused = false;
533
534 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
535 EXPECT_EQ(proxy_->CheckUIExtensionIsFocused(uiExtensionTokenId, isFocused), INVALID_PARAMETERS_ERR);
536
537 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_CheckUIExtensionIsFocused_0100 end");
538 }
539
540 /**
541 * @tc.name: AbilityManagerProxy_DelegatorDoAbilityForeground_0100
542 * @tc.desc: DelegatorDoAbilityForeground
543 * @tc.type: FUNC
544 */
545 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityForeground_0100, TestSize.Level1)
546 {
547 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DelegatorDoAbilityForeground_0100 start");
548
549 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
550
551 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
552 EXPECT_EQ(proxy_->DelegatorDoAbilityForeground(token), INVALID_PARAMETERS_ERR);
553
554 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
555 EXPECT_EQ(proxy_->DelegatorDoAbilityForeground(token), NO_ERROR);
556
557 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DelegatorDoAbilityForeground_0100 end");
558 }
559
560 /**
561 * @tc.name: AbilityManagerProxy_DelegatorDoAbilityBackground_0100
562 * @tc.desc: DelegatorDoAbilityBackground
563 * @tc.type: FUNC
564 */
565 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityBackground_0100, TestSize.Level1)
566 {
567 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DelegatorDoAbilityBackground_0100 start");
568
569 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
570
571 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
572 EXPECT_EQ(proxy_->DelegatorDoAbilityBackground(token), INVALID_PARAMETERS_ERR);
573
574 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
575 EXPECT_EQ(proxy_->DelegatorDoAbilityBackground(token), NO_ERROR);
576
577 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DelegatorDoAbilityBackground_0100 end");
578 }
579
580 /**
581 * @tc.name: AbilityManagerProxy_DoAbilityForeground_0100
582 * @tc.desc: DoAbilityForeground
583 * @tc.type: FUNC
584 */
585 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityForeground_0100, TestSize.Level1)
586 {
587 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DoAbilityForeground_0100 start");
588
589 uint32_t flag = 0;
590 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
591
592 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
593 EXPECT_EQ(proxy_->DoAbilityForeground(token, flag), INVALID_PARAMETERS_ERR);
594
595 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
596 EXPECT_EQ(proxy_->DoAbilityForeground(token, flag), NO_ERROR);
597
598 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DoAbilityForeground_0100 end");
599 }
600
601 /**
602 * @tc.name: AbilityManagerProxy_DoAbilityBackground_0100
603 * @tc.desc: DoAbilityBackground
604 * @tc.type: FUNC
605 */
606 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityBackground_0100, TestSize.Level1)
607 {
608 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DoAbilityBackground_0100 start");
609
610 uint32_t flag = 0;
611 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
612
613 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
614 EXPECT_EQ(proxy_->DoAbilityBackground(token, flag), INVALID_PARAMETERS_ERR);
615
616 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
617 EXPECT_EQ(proxy_->DoAbilityBackground(token, flag), NO_ERROR);
618
619 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DoAbilityBackground_0100 end");
620 }
621 } // namespace AAFwk
622 } // namespace OHOS