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
16 #include <gtest/gtest.h>
17
18 #include "ability_manager_errors.h"
19 #include "ability_manager_proxy.h"
20 #include "ability_manager_stub_mock.h"
21 #include "ability_record.h"
22 #include "ability_scheduler.h"
23 #include "ability_scheduler_mock.h"
24 #include "ability_start_setting.h"
25 #include "app_debug_listener_stub_mock.h"
26 #include "hilog_tag_wrapper.h"
27 #include "mission_snapshot.h"
28 #include "mock_ability_connect_callback.h"
29 #include "mock_ability_token.h"
30 #include "want_sender_info.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34 using namespace OHOS::AppExecFwk;
35
36 namespace OHOS {
37 namespace AAFwk {
38 namespace {
39 constexpr uint32_t RETURN_NUMBER_ONE = 1053;
40 constexpr uint32_t RETURN_NUMBER_TWO = 6132;
41 } // namespace
42
43 class AbilityManagerProxyTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp();
48 void TearDown();
49
50 std::shared_ptr<AbilityManagerProxy> proxy_ { nullptr };
51 sptr<AbilityManagerStubMock> mock_ { nullptr };
52 };
53
54 class MockIAbilityConnection : public IAbilityConnection {
55 public:
56 MockIAbilityConnection() = default;
57
58 virtual ~MockIAbilityConnection() = default;
59
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)60 void OnAbilityConnectDone(
61 const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) override {};
62
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)63 void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override {};
64
AsObject()65 sptr<IRemoteObject> AsObject() override
66 {
67 return iremoteObject_;
68 }
69
70 sptr<IRemoteObject> iremoteObject_ = nullptr;
71 };
72
73 class MockIUserCallback : public IUserCallback {
74 public:
75 MockIUserCallback() = default;
76 virtual ~MockIUserCallback() = default;
77
OnStopUserDone(int userId,int errcode)78 void OnStopUserDone(int userId, int errcode) override {}
OnStartUserDone(int userId,int errcode)79 void OnStartUserDone(int userId, int errcode) override {}
80
OnLogoutUserDone(int userId,int errcode)81 void OnLogoutUserDone(int userId, int errcode) override {}
82
AsObject()83 sptr<IRemoteObject> AsObject() override
84 {
85 return iremoteObject_;
86 }
87 sptr<IRemoteObject> iremoteObject_ = nullptr;
88 };
89
90 #ifdef SUPPORT_SCREEN
91 class MockIWindowManagerServiceHandler : public IWindowManagerServiceHandler {
92 public:
NotifyWindowTransition(sptr<AbilityTransitionInfo> fromInfo,sptr<AbilityTransitionInfo> toInfo,bool & animaEnabled)93 void NotifyWindowTransition(
94 sptr<AbilityTransitionInfo> fromInfo, sptr<AbilityTransitionInfo> toInfo, bool& animaEnabled) override {};
95
GetFocusWindow(sptr<IRemoteObject> & abilityToken)96 int32_t GetFocusWindow(sptr<IRemoteObject>& abilityToken) override
97 {
98 return 0;
99 };
100
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap,uint32_t bgColor)101 void StartingWindow(
102 sptr<AbilityTransitionInfo> info, std::shared_ptr<Media::PixelMap> pixelMap, uint32_t bgColor) override {};
103
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap)104 void StartingWindow(sptr<AbilityTransitionInfo> info, std::shared_ptr<Media::PixelMap> pixelMap) override {};
105
CancelStartingWindow(sptr<IRemoteObject> abilityToken)106 void CancelStartingWindow(sptr<IRemoteObject> abilityToken) override {};
107
NotifyAnimationAbilityDied(sptr<AbilityTransitionInfo> info)108 void NotifyAnimationAbilityDied(sptr<AbilityTransitionInfo> info) override {};
109
MoveMissionsToForeground(const std::vector<int32_t> & missionIds,int32_t topMissionId)110 int32_t MoveMissionsToForeground(const std::vector<int32_t>& missionIds, int32_t topMissionId) override
111 {
112 return 0;
113 };
114
MoveMissionsToBackground(const std::vector<int32_t> & missionIds,std::vector<int32_t> & result)115 int32_t MoveMissionsToBackground(const std::vector<int32_t>& missionIds, std::vector<int32_t>& result) override
116 {
117 return 0;
118 };
119
AsObject()120 sptr<IRemoteObject> AsObject() override
121 {
122 return iremoteObject_;
123 }
124 sptr<IRemoteObject> iremoteObject_ = nullptr;
125 };
126
127 class MockIPrepareTerminateCallback : public IPrepareTerminateCallback {
128 public:
DoPrepareTerminate()129 void DoPrepareTerminate() override {};
AsObject()130 sptr<IRemoteObject> AsObject() override
131 {
132 return iremoteObject_;
133 }
134 sptr<IRemoteObject> iremoteObject_ = nullptr;
135 };
136
137 class MockIAbilityFirstFrameStateObserver : public IAbilityFirstFrameStateObserver {
138 public:
OnAbilityFirstFrameState(const AbilityFirstFrameStateData & abilityFirstFrameStateData)139 void OnAbilityFirstFrameState(const AbilityFirstFrameStateData& abilityFirstFrameStateData) override {};
140
AsObject()141 sptr<IRemoteObject> AsObject() override
142 {
143 return iremoteObject_;
144 }
145 sptr<IRemoteObject> iremoteObject_ = nullptr;
146 };
147 #endif // SUPPORT_SCREEN
148
SetUpTestCase(void)149 void AbilityManagerProxyTest::SetUpTestCase(void) {}
150
TearDownTestCase(void)151 void AbilityManagerProxyTest::TearDownTestCase(void) {}
152
TearDown()153 void AbilityManagerProxyTest::TearDown() {}
154
SetUp()155 void AbilityManagerProxyTest::SetUp()
156 {
157 mock_ = new (std::nothrow) AbilityManagerStubMock();
158 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
159 }
160
161 /**
162 * @tc.name: StartSelfUIAbility_0100
163 * @tc.desc: StartSelfUIAbility
164 * @tc.type: FUNC
165 */
166 HWTEST_F(AbilityManagerProxyTest, StartSelfUIAbility_0100, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "StartSelfUIAbility_0100 start";
169
170 Want want;
171 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
172 .Times(1)
173 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
174 int32_t result = proxy_->StartSelfUIAbility(want);
175 EXPECT_EQ(RETURN_NUMBER_TWO, mock_->code_);
176 EXPECT_NE(result, NO_ERROR);
177
178 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
179 .Times(1)
180 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
181 result = proxy_->StartSelfUIAbility(want);
182 EXPECT_EQ(RETURN_NUMBER_TWO, mock_->code_);
183 EXPECT_EQ(result, NO_ERROR);
184
185 GTEST_LOG_(INFO) << "StartSelfUIAbility_0100 end";
186 }
187
188 /**
189 * @tc.name: StartSelfUIAbilityWithStartOptions_0200
190 * @tc.desc: StartSelfUIAbilityWithStartOptions
191 * @tc.type: FUNC
192 */
193 HWTEST_F(AbilityManagerProxyTest, StartSelfUIAbilityWithStartOptions_0200, TestSize.Level1)
194 {
195 GTEST_LOG_(INFO) << "StartSelfUIAbilityWithStartOptions_0200 start";
196
197 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
198 .Times(1)
199 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
200 Want want;
201 StartOptions options;
202 int32_t result = proxy_->StartSelfUIAbilityWithStartOptions(want, options);
203 EXPECT_EQ(
204 static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SELF_UI_ABILITY_WITH_START_OPTIONS), mock_->code_);
205 EXPECT_NE(result, NO_ERROR);
206
207 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
208 .Times(1)
209 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
210 result = proxy_->StartSelfUIAbilityWithStartOptions(want, options);
211 EXPECT_EQ(
212 static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SELF_UI_ABILITY_WITH_START_OPTIONS), mock_->code_);
213 EXPECT_EQ(result, NO_ERROR);
214
215 GTEST_LOG_(INFO) << "StartSelfUIAbilityWithStartOptions_0200 end";
216 }
217
218 /**
219 * @tc.name: StartAbility_0300
220 * @tc.desc: StartAbility
221 * @tc.type: FUNC
222 */
223 HWTEST_F(AbilityManagerProxyTest, StartAbility_0300, TestSize.Level1)
224 {
225 GTEST_LOG_(INFO) << "StartAbility_0300 start";
226
227 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
228 .Times(1)
229 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
230 Want want;
231 int32_t result = proxy_->StartAbility(want, 1, 1);
232 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY), mock_->code_);
233 EXPECT_NE(result, NO_ERROR);
234
235 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
236 .Times(1)
237 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
238 result = proxy_->StartAbility(want, 1, 1);
239 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY), mock_->code_);
240 EXPECT_EQ(result, NO_ERROR);
241
242 GTEST_LOG_(INFO) << "StartAbility_0300 end";
243 }
244
245 /**
246 * @tc.name: StartAbility_0400
247 * @tc.desc: StartAbility
248 * @tc.type: FUNC
249 */
250 HWTEST_F(AbilityManagerProxyTest, StartAbility_0400, TestSize.Level1)
251 {
252 GTEST_LOG_(INFO) << "StartAbility_0400 start";
253
254 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
255 .Times(1)
256 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
257 Want want;
258 sptr<IRemoteObject> callerToken = nullptr;
259 int32_t result = proxy_->StartAbility(want, callerToken, 1, 1);
260 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ADD_CALLER), mock_->code_);
261 EXPECT_NE(result, NO_ERROR);
262
263 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
264 .Times(1)
265 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
266 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
267 EXPECT_NE(callerToken, nullptr);
268 result = proxy_->StartAbility(want, callerToken, 1, 1);
269 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ADD_CALLER), mock_->code_);
270 EXPECT_EQ(result, NO_ERROR);
271
272 GTEST_LOG_(INFO) << "StartAbility_0400 end";
273 }
274
275 /**
276 * @tc.name: StartAbilityWithSpecifyTokenId_0500
277 * @tc.desc: StartAbilityWithSpecifyTokenId
278 * @tc.type: FUNC
279 */
280 HWTEST_F(AbilityManagerProxyTest, StartAbilityWithSpecifyTokenId_0500, TestSize.Level1)
281 {
282 GTEST_LOG_(INFO) << "StartAbilityWithSpecifyTokenId_0500 start";
283
284 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
285 .Times(1)
286 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
287 Want want;
288 sptr<IRemoteObject> callerToken = nullptr;
289 int32_t result = proxy_->StartAbilityWithSpecifyTokenId(want, callerToken, 1, 1, 1);
290 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_WITH_SPECIFY_TOKENID), mock_->code_);
291 EXPECT_NE(result, NO_ERROR);
292
293 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
294 .Times(1)
295 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
296 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
297 EXPECT_NE(callerToken, nullptr);
298 result = proxy_->StartAbilityWithSpecifyTokenId(want, callerToken, 1, 1, 1);
299 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_WITH_SPECIFY_TOKENID), mock_->code_);
300 EXPECT_EQ(result, NO_ERROR);
301
302 GTEST_LOG_(INFO) << "StartAbilityWithSpecifyTokenId_0500 end";
303 }
304
305 /**
306 * @tc.name: StartAbilityByInsightIntent_0600
307 * @tc.desc: StartAbilityByInsightIntent
308 * @tc.type: FUNC
309 */
310 HWTEST_F(AbilityManagerProxyTest, StartAbilityByInsightIntent_0600, TestSize.Level1)
311 {
312 GTEST_LOG_(INFO) << "StartAbilityByInsightIntent_0600 start";
313
314 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
315 .Times(1)
316 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
317 Want want;
318 sptr<IRemoteObject> callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
319 EXPECT_NE(callerToken, nullptr);
320 int32_t result = proxy_->StartAbilityByInsightIntent(want, callerToken, 1, 1);
321 EXPECT_EQ(RETURN_NUMBER_ONE, mock_->code_);
322 EXPECT_NE(result, NO_ERROR);
323
324 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
325 .Times(1)
326 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
327 result = proxy_->StartAbilityByInsightIntent(want, callerToken, 1, 1);
328 EXPECT_EQ(RETURN_NUMBER_ONE, mock_->code_);
329 EXPECT_EQ(result, NO_ERROR);
330
331 GTEST_LOG_(INFO) << "StartAbilityByInsightIntent_0600 end";
332 }
333
334 /**
335 * @tc.name: StartUIExtensionAbility_0700
336 * @tc.desc: StartUIExtensionAbility
337 * @tc.type: FUNC
338 */
339 HWTEST_F(AbilityManagerProxyTest, StartUIExtensionAbility_0700, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0700 start";
342
343 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
344 .Times(1)
345 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
346 sptr<SessionInfo> extensionSessionInfoTest = new (std::nothrow) SessionInfo();
347 EXPECT_NE(extensionSessionInfoTest, nullptr);
348 extensionSessionInfoTest->uiExtensionUsage = UIExtensionUsage::CONSTRAINED_EMBEDDED;
349 int32_t result = proxy_->StartUIExtensionAbility(extensionSessionInfoTest, 1);
350 EXPECT_EQ(
351 static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_CONSTRAINED_EMBEDDED), mock_->code_);
352 EXPECT_EQ(result, NO_ERROR);
353
354 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0700 end";
355 }
356
357 /**
358 * @tc.name: StartAbility_0800
359 * @tc.desc: StartAbility
360 * @tc.type: FUNC
361 */
362 HWTEST_F(AbilityManagerProxyTest, StartAbility_0800, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "StartAbility_0800 start";
365
366 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
367 .Times(1)
368 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
369 Want want;
370 StartOptions startOptions;
371 sptr<IRemoteObject> callerToken = nullptr;
372 int32_t result = proxy_->StartAbility(want, startOptions, callerToken, 1, 1);
373 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_OPTIONS), mock_->code_);
374 EXPECT_NE(result, NO_ERROR);
375
376 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
377 .Times(1)
378 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
379 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
380 EXPECT_NE(callerToken, nullptr);
381 result = proxy_->StartAbility(want, startOptions, callerToken, 1, 1);
382 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_OPTIONS), mock_->code_);
383 EXPECT_EQ(result, NO_ERROR);
384
385 GTEST_LOG_(INFO) << "StartAbility_0800 end";
386 }
387
388 /**
389 * @tc.name: StartAbilityAsCaller_0900
390 * @tc.desc: StartAbilityAsCaller
391 * @tc.type: FUNC
392 */
393 HWTEST_F(AbilityManagerProxyTest, StartAbility_0900, TestSize.Level1)
394 {
395 GTEST_LOG_(INFO) << "StartAbility_0900 start";
396
397 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
398 .Times(1)
399 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
400 Want want;
401 sptr<IRemoteObject> callerToken = nullptr;
402 sptr<IRemoteObject> asCallerSourceToken = nullptr;
403 int32_t result = proxy_->StartAbilityAsCaller(want, callerToken, asCallerSourceToken, 1, 1);
404 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_BY_TOKEN), mock_->code_);
405 EXPECT_NE(result, NO_ERROR);
406
407 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
408 .Times(1)
409 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
410 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
411 EXPECT_NE(callerToken, nullptr);
412 asCallerSourceToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
413 EXPECT_NE(asCallerSourceToken, nullptr);
414 result = proxy_->StartAbilityAsCaller(want, callerToken, asCallerSourceToken, 1, 1);
415 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_BY_TOKEN), mock_->code_);
416 EXPECT_EQ(result, NO_ERROR);
417
418 GTEST_LOG_(INFO) << "StartAbility_0900 end";
419 }
420
421 /**
422 * @tc.name: StartAbilityAsCaller_1000
423 * @tc.desc: StartAbilityAsCaller
424 * @tc.type: FUNC
425 */
426 HWTEST_F(AbilityManagerProxyTest, StartAbilityAsCaller_1000, TestSize.Level1)
427 {
428 GTEST_LOG_(INFO) << "StartAbilityAsCaller_1000 start";
429
430 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
431 .Times(1)
432 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
433 Want want;
434 StartOptions startOptions;
435 sptr<IRemoteObject> callerToken = nullptr;
436 sptr<IRemoteObject> asCallerSourceToken = nullptr;
437 int32_t result = proxy_->StartAbilityAsCaller(want, startOptions, callerToken, asCallerSourceToken, 1, 1);
438 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_FOR_OPTIONS), mock_->code_);
439 EXPECT_NE(result, NO_ERROR);
440
441 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
442 .Times(1)
443 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
444 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
445 EXPECT_NE(callerToken, nullptr);
446 asCallerSourceToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
447 EXPECT_NE(asCallerSourceToken, nullptr);
448 result = proxy_->StartAbilityAsCaller(want, startOptions, callerToken, asCallerSourceToken, 1, 1);
449 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_FOR_OPTIONS), mock_->code_);
450 EXPECT_EQ(result, NO_ERROR);
451
452 GTEST_LOG_(INFO) << "StartAbilityAsCaller_1000 end";
453 }
454
455 /**
456 * @tc.name: StartAbilityForResultAsCaller_1100
457 * @tc.desc: StartAbilityForResultAsCaller
458 * @tc.type: FUNC
459 */
460 HWTEST_F(AbilityManagerProxyTest, StartAbilityForResultAsCaller_1100, TestSize.Level1)
461 {
462 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_1100 start";
463
464 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
465 .Times(1)
466 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
467 Want want;
468 sptr<IRemoteObject> callerToken = nullptr;
469 int32_t result = proxy_->StartAbilityForResultAsCaller(want, callerToken, 1, 1);
470 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER), mock_->code_);
471 EXPECT_NE(result, NO_ERROR);
472
473 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
474 .Times(1)
475 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
476 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
477 EXPECT_NE(callerToken, nullptr);
478 result = proxy_->StartAbilityForResultAsCaller(want, callerToken, 1, 1);
479 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER), mock_->code_);
480 EXPECT_EQ(result, NO_ERROR);
481
482 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_1100 end";
483 }
484
485 /**
486 * @tc.name: StartAbilityForResultAsCaller_1200
487 * @tc.desc: StartAbilityForResultAsCaller
488 * @tc.type: FUNC
489 */
490 HWTEST_F(AbilityManagerProxyTest, StartAbilityForResultAsCaller_1200, TestSize.Level1)
491 {
492 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_1200 start";
493
494 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
495 .Times(1)
496 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
497 Want want;
498 StartOptions startOptions;
499 sptr<IRemoteObject> callerToken = nullptr;
500 int32_t result = proxy_->StartAbilityForResultAsCaller(want, startOptions, callerToken, 1, 1);
501 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER_FOR_OPTIONS),
502 mock_->code_);
503 EXPECT_NE(result, NO_ERROR);
504
505 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
506 .Times(1)
507 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
508 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
509 EXPECT_NE(callerToken, nullptr);
510 result = proxy_->StartAbilityForResultAsCaller(want, startOptions, callerToken, 1, 1);
511 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER_FOR_OPTIONS),
512 mock_->code_);
513 EXPECT_EQ(result, NO_ERROR);
514
515 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_1200 end";
516 }
517
518 /**
519 * @tc.name: StartAbilityByUIContentSession_1300
520 * @tc.desc: StartAbilityByUIContentSession
521 * @tc.type: FUNC
522 */
523 HWTEST_F(AbilityManagerProxyTest, StartAbilityByUIContentSession_1300, TestSize.Level1)
524 {
525 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_1300 start";
526
527 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
528 .Times(1)
529 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
530 Want want;
531 sptr<IRemoteObject> callerToken = nullptr;
532 sptr<SessionInfo> sessionInfo = nullptr;
533 int32_t result = proxy_->StartAbilityByUIContentSession(want, callerToken, sessionInfo, 1, 1);
534 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_ADD_CALLER), mock_->code_);
535 EXPECT_NE(result, NO_ERROR);
536
537 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
538 .Times(1)
539 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
540 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
541 EXPECT_NE(callerToken, nullptr);
542 sessionInfo = new (std::nothrow) SessionInfo();
543 EXPECT_NE(sessionInfo, nullptr);
544 result = proxy_->StartAbilityByUIContentSession(want, callerToken, sessionInfo, 1, 1);
545 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_ADD_CALLER), mock_->code_);
546 EXPECT_EQ(result, NO_ERROR);
547
548 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_1300 end";
549 }
550
551 /**
552 * @tc.name: StartAbilityByUIContentSession_1400
553 * @tc.desc: StartAbilityByUIContentSession
554 * @tc.type: FUNC
555 */
556 HWTEST_F(AbilityManagerProxyTest, StartAbilityByUIContentSession_1400, TestSize.Level1)
557 {
558 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_1400 start";
559
560 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
561 .Times(1)
562 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
563 Want want;
564 StartOptions startOptions;
565 sptr<IRemoteObject> callerToken = nullptr;
566 sptr<SessionInfo> sessionInfo = nullptr;
567 int32_t result = proxy_->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, 1, 1);
568 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_FOR_OPTIONS), mock_->code_);
569 EXPECT_NE(result, NO_ERROR);
570
571 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
572 .Times(1)
573 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
574 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
575 EXPECT_NE(callerToken, nullptr);
576 sessionInfo = new (std::nothrow) SessionInfo();
577 EXPECT_NE(sessionInfo, nullptr);
578 result = proxy_->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, 1, 1);
579 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_FOR_OPTIONS), mock_->code_);
580 EXPECT_EQ(result, NO_ERROR);
581
582 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_1400 end";
583 }
584
585 /**
586 * @tc.name: StartAbilityOnlyUIAbility_1500
587 * @tc.desc: StartAbilityOnlyUIAbility
588 * @tc.type: FUNC
589 */
590 HWTEST_F(AbilityManagerProxyTest, StartAbilityOnlyUIAbility_1500, TestSize.Level1)
591 {
592 GTEST_LOG_(INFO) << "StartAbilityOnlyUIAbility_1500 start";
593
594 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
595 .Times(1)
596 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
597 Want want;
598 sptr<IRemoteObject> callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
599 EXPECT_NE(callerToken, nullptr);
600 int32_t result = proxy_->StartAbilityOnlyUIAbility(want, callerToken, 1);
601 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ONLY_UI_ABILITY), mock_->code_);
602 EXPECT_NE(result, NO_ERROR);
603
604 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
605 .Times(1)
606 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
607 result = proxy_->StartAbilityOnlyUIAbility(want, callerToken, 1);
608 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ONLY_UI_ABILITY), mock_->code_);
609 EXPECT_EQ(result, NO_ERROR);
610
611 GTEST_LOG_(INFO) << "StartAbilityOnlyUIAbility_1500 end";
612 }
613
614 /**
615 * @tc.name: StartExtensionAbility_1600
616 * @tc.desc: StartExtensionAbility
617 * @tc.type: FUNC
618 */
619 HWTEST_F(AbilityManagerProxyTest, StartExtensionAbility_1600, TestSize.Level1)
620 {
621 GTEST_LOG_(INFO) << "StartExtensionAbility_1600 start";
622
623 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
624 .Times(1)
625 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
626 Want want;
627 sptr<IRemoteObject> callerToken = nullptr;
628 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::WORK_SCHEDULER;
629 int32_t result = proxy_->StartExtensionAbility(want, callerToken, 1, extensionType);
630 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_EXTENSION_ABILITY), mock_->code_);
631 EXPECT_NE(result, NO_ERROR);
632
633 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
634 .Times(1)
635 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
636 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
637 EXPECT_NE(callerToken, nullptr);
638 result = proxy_->StartExtensionAbility(want, callerToken, 1, extensionType);
639 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_EXTENSION_ABILITY), mock_->code_);
640 EXPECT_EQ(result, NO_ERROR);
641
642 GTEST_LOG_(INFO) << "StartExtensionAbility_1600 end";
643 }
644
645 /**
646 * @tc.name: PreloadUIExtensionAbility_1700
647 * @tc.desc: PreloadUIExtensionAbility
648 * @tc.type: FUNC
649 */
650 HWTEST_F(AbilityManagerProxyTest, PreloadUIExtensionAbility_1700, TestSize.Level1)
651 {
652 GTEST_LOG_(INFO) << "PreloadUIExtensionAbility_1700 start";
653
654 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
655 .Times(1)
656 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
657 Want want;
658 std::string hostBundleName = "test";
659 int32_t result = proxy_->PreloadUIExtensionAbility(want, hostBundleName, 1, 1);
660 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::PRELOAD_UIEXTENSION_ABILITY), mock_->code_);
661 EXPECT_NE(result, NO_ERROR);
662
663 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
664 .Times(1)
665 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
666 result = proxy_->PreloadUIExtensionAbility(want, hostBundleName, 1, 1);
667 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::PRELOAD_UIEXTENSION_ABILITY), mock_->code_);
668 EXPECT_EQ(result, NO_ERROR);
669
670 GTEST_LOG_(INFO) << "PreloadUIExtensionAbility_1700 end";
671 }
672
673 /**
674 * @tc.name: ChangeAbilityVisibility_1800
675 * @tc.desc: ChangeAbilityVisibility
676 * @tc.type: FUNC
677 */
678 HWTEST_F(AbilityManagerProxyTest, ChangeAbilityVisibility_1800, TestSize.Level1)
679 {
680 GTEST_LOG_(INFO) << "ChangeAbilityVisibility_1800 start";
681
682 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
683 .Times(1)
684 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
685 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
686 EXPECT_NE(token, nullptr);
687 int32_t result = proxy_->ChangeAbilityVisibility(token, false);
688 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_ABILITY_VISIBILITY), mock_->code_);
689 EXPECT_NE(result, NO_ERROR);
690
691 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
692 .Times(1)
693 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
694 result = proxy_->ChangeAbilityVisibility(token, false);
695 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_ABILITY_VISIBILITY), mock_->code_);
696 EXPECT_EQ(result, NO_ERROR);
697
698 GTEST_LOG_(INFO) << "ChangeAbilityVisibility_1800 end";
699 }
700
701 /**
702 * @tc.name: ChangeUIAbilityVisibilityBySCB_1900
703 * @tc.desc: ChangeUIAbilityVisibilityBySCB
704 * @tc.type: FUNC
705 */
706 HWTEST_F(AbilityManagerProxyTest, ChangeUIAbilityVisibilityBySCB_1900, TestSize.Level1)
707 {
708 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_1900 start";
709
710 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
711 .Times(1)
712 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
713 sptr<SessionInfo> sessionInfo = nullptr;
714 int32_t result = proxy_->ChangeUIAbilityVisibilityBySCB(sessionInfo, false);
715 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_UI_ABILITY_VISIBILITY_BY_SCB), mock_->code_);
716 EXPECT_NE(result, NO_ERROR);
717
718 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
719 .Times(1)
720 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
721 sessionInfo = new (std::nothrow) SessionInfo();
722 EXPECT_NE(sessionInfo, nullptr);
723 result = proxy_->ChangeUIAbilityVisibilityBySCB(sessionInfo, false);
724 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_UI_ABILITY_VISIBILITY_BY_SCB), mock_->code_);
725 EXPECT_EQ(result, NO_ERROR);
726
727 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_1900 end";
728 }
729
730 /**
731 * @tc.name: StartUIExtensionAbility_2000
732 * @tc.desc: StartUIExtensionAbility
733 * @tc.type: FUNC
734 */
735 HWTEST_F(AbilityManagerProxyTest, StartUIExtensionAbility_2000, TestSize.Level1)
736 {
737 GTEST_LOG_(INFO) << "StartUIExtensionAbility_2000 start";
738
739 sptr<SessionInfo> extensionSessionInfoTest = new (std::nothrow) SessionInfo();
740 EXPECT_NE(extensionSessionInfoTest, nullptr);
741 extensionSessionInfoTest->uiExtensionUsage = UIExtensionUsage::EMBEDDED;
742 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
743 .Times(1)
744 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
745 int32_t result = proxy_->StartUIExtensionAbility(extensionSessionInfoTest, 1);
746 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_ABILITY_EMBEDDED), mock_->code_);
747 EXPECT_NE(result, NO_ERROR);
748 result = proxy_->StartUIExtensionAbility(nullptr, 1);
749 EXPECT_NE(result, NO_ERROR);
750
751 GTEST_LOG_(INFO) << "StartUIExtensionAbility_2000 end";
752 }
753
754 /**
755 * @tc.name: StartUIExtensionAbility_2100
756 * @tc.desc: StartUIExtensionAbility
757 * @tc.type: FUNC
758 */
759 HWTEST_F(AbilityManagerProxyTest, StartUIExtensionAbility_2100, TestSize.Level1)
760 {
761 GTEST_LOG_(INFO) << "StartUIExtensionAbility_2100 start";
762
763 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
764 .Times(1)
765 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
766 sptr<SessionInfo> extensionSessionInfoTest = new (std::nothrow) SessionInfo();
767 EXPECT_NE(extensionSessionInfoTest, nullptr);
768 extensionSessionInfoTest->uiExtensionUsage = UIExtensionUsage::MODAL;
769 int32_t result = proxy_->StartUIExtensionAbility(extensionSessionInfoTest, 1);
770 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_ABILITY), mock_->code_);
771 EXPECT_NE(result, NO_ERROR);
772
773 GTEST_LOG_(INFO) << "StartUIExtensionAbility_2100 end";
774 }
775
776 /**
777 * @tc.name: CleanMission_2200
778 * @tc.desc: CleanMission
779 * @tc.type: FUNC
780 */
781 HWTEST_F(AbilityManagerProxyTest, CleanMission_2200, TestSize.Level1)
782 {
783 GTEST_LOG_(INFO) << "CleanMission_2200 start";
784
785 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
786 .Times(1)
787 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
788 int32_t result = proxy_->CleanMission(1);
789 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_MISSION), mock_->code_);
790 EXPECT_NE(result, NO_ERROR);
791
792 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
793 .Times(1)
794 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
795 result = proxy_->CleanMission(1);
796 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_MISSION), mock_->code_);
797 EXPECT_EQ(result, NO_ERROR);
798
799 GTEST_LOG_(INFO) << "CleanMission_2200 end";
800 }
801
802 /**
803 * @tc.name: CleanAllMissions_2300
804 * @tc.desc: CleanAllMissions
805 * @tc.type: FUNC
806 */
807 HWTEST_F(AbilityManagerProxyTest, CleanAllMissions_2300, TestSize.Level1)
808 {
809 GTEST_LOG_(INFO) << "CleanAllMissions_2300 start";
810
811 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
812 .Times(1)
813 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
814 int32_t result = proxy_->CleanAllMissions();
815 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_ALL_MISSIONS), mock_->code_);
816 EXPECT_NE(result, NO_ERROR);
817
818 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
819 .Times(1)
820 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
821 result = proxy_->CleanAllMissions();
822 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_ALL_MISSIONS), mock_->code_);
823 EXPECT_EQ(result, NO_ERROR);
824
825 GTEST_LOG_(INFO) << "CleanAllMissions_2300 end";
826 }
827
828 /**
829 * @tc.name: MoveMissionToFront_2400
830 * @tc.desc: MoveMissionToFront
831 * @tc.type: FUNC
832 */
833 HWTEST_F(AbilityManagerProxyTest, MoveMissionToFront_2400, TestSize.Level1)
834 {
835 GTEST_LOG_(INFO) << "MoveMissionToFront_2400 start";
836
837 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
838 .Times(1)
839 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
840 int32_t result = proxy_->MoveMissionToFront(1);
841 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT), mock_->code_);
842 EXPECT_NE(result, NO_ERROR);
843
844 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
845 .Times(1)
846 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
847 result = proxy_->MoveMissionToFront(1);
848 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT), mock_->code_);
849 EXPECT_EQ(result, NO_ERROR);
850
851 GTEST_LOG_(INFO) << "MoveMissionToFront_2400 end";
852 }
853
854 /**
855 * @tc.name: MoveMissionToFront_2500
856 * @tc.desc: MoveMissionToFront
857 * @tc.type: FUNC
858 */
859 HWTEST_F(AbilityManagerProxyTest, MoveMissionToFront_2500, TestSize.Level1)
860 {
861 GTEST_LOG_(INFO) << "MoveMissionToFront_2500 start";
862
863 StartOptions startOptions;
864 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
865 .Times(1)
866 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
867 int32_t result = proxy_->MoveMissionToFront(1, startOptions);
868 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT_BY_OPTIONS), mock_->code_);
869 EXPECT_NE(result, NO_ERROR);
870
871 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
872 .Times(1)
873 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
874 result = proxy_->MoveMissionToFront(1, startOptions);
875 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT_BY_OPTIONS), mock_->code_);
876 EXPECT_EQ(result, NO_ERROR);
877
878 GTEST_LOG_(INFO) << "MoveMissionToFront_2500 end";
879 }
880
881 /**
882 * @tc.name: MoveMissionsToForeground_2600
883 * @tc.desc: MoveMissionsToForeground
884 * @tc.type: FUNC
885 */
886 HWTEST_F(AbilityManagerProxyTest, MoveMissionsToForeground_2600, TestSize.Level1)
887 {
888 GTEST_LOG_(INFO) << "MoveMissionsToForeground_2600 start";
889
890 std::vector<int32_t> missionIds;
891 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
892 .Times(1)
893 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
894 int32_t result = proxy_->MoveMissionsToForeground(missionIds, 1);
895 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_FOREGROUND), mock_->code_);
896 EXPECT_NE(result, NO_ERROR);
897
898 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
899 .Times(1)
900 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
901 result = proxy_->MoveMissionsToForeground(missionIds, 1);
902 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_FOREGROUND), mock_->code_);
903 EXPECT_EQ(result, NO_ERROR);
904
905 GTEST_LOG_(INFO) << "MoveMissionsToForeground_2600 end";
906 }
907
908 /**
909 * @tc.name: MoveMissionsToBackground_2700
910 * @tc.desc: MoveMissionsToBackground
911 * @tc.type: FUNC
912 */
913 HWTEST_F(AbilityManagerProxyTest, MoveMissionsToBackground_2700, TestSize.Level1)
914 {
915 GTEST_LOG_(INFO) << "MoveMissionsToBackground_2700 start";
916
917 std::vector<int32_t> missionIds;
918 std::vector<int32_t> results;
919 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
920 .Times(1)
921 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
922 int32_t result = proxy_->MoveMissionsToBackground(missionIds, results);
923 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_BACKGROUND), mock_->code_);
924 EXPECT_NE(result, NO_ERROR);
925
926 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
927 .Times(1)
928 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
929 result = proxy_->MoveMissionsToBackground(missionIds, results);
930 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_BACKGROUND), mock_->code_);
931 EXPECT_EQ(result, NO_ERROR);
932
933 GTEST_LOG_(INFO) << "MoveMissionsToBackground_2700 end";
934 }
935
936 /**
937 * @tc.name: StartAbilityByCall_2800
938 * @tc.desc: StartAbilityByCall and StartAbilityByCallWithErrMsg
939 * @tc.type: FUNC
940 */
941 HWTEST_F(AbilityManagerProxyTest, StartAbilityByCall_2800, TestSize.Level1)
942 {
943 GTEST_LOG_(INFO) << "StartAbilityByCall_2800 start";
944
945 Want want;
946 sptr<IAbilityConnection> connect = nullptr;
947 sptr<IRemoteObject> callerToken = nullptr;
948 int32_t accountId = 1;
949 int32_t result = proxy_->StartAbilityByCall(want, connect, callerToken, accountId);
950 EXPECT_NE(result, NO_ERROR);
951
952 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
953 .Times(1)
954 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
955
956 sptr<MockIAbilityConnection> mockIAbilityConnection = new (std::nothrow) MockIAbilityConnection();
957 mockIAbilityConnection->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
958 connect = mockIAbilityConnection;
959 result = proxy_->StartAbilityByCall(want, connect, callerToken, accountId);
960 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY), mock_->code_);
961 EXPECT_NE(result, NO_ERROR);
962
963 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
964 .Times(1)
965 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
966 callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
967 result = proxy_->StartAbilityByCall(want, connect, callerToken, accountId);
968 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY), mock_->code_);
969 EXPECT_EQ(result, NO_ERROR);
970
971 GTEST_LOG_(INFO) << "StartAbilityByCall_2800 end";
972 }
973
974 /**
975 * @tc.name: ReleaseCall_2900
976 * @tc.desc: ReleaseCall
977 * @tc.type: FUNC
978 */
979 HWTEST_F(AbilityManagerProxyTest, ReleaseCall_2900, TestSize.Level1)
980 {
981 GTEST_LOG_(INFO) << "ReleaseCall_2900 start";
982
983 AppExecFwk::ElementName element;
984 sptr<IAbilityConnection> connect = nullptr;
985 int32_t accountId = 1;
986 int32_t result = proxy_->ReleaseCall(connect, element);
987 EXPECT_NE(result, NO_ERROR);
988
989 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
990 .Times(1)
991 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
992 sptr<MockIAbilityConnection> mockIAbilityConnection = new (std::nothrow) MockIAbilityConnection();
993 mockIAbilityConnection->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
994 connect = mockIAbilityConnection;
995 result = proxy_->ReleaseCall(connect, element);
996 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY), mock_->code_);
997 EXPECT_NE(result, NO_ERROR);
998
999 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1000 .Times(1)
1001 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1002 result = proxy_->ReleaseCall(connect, element);
1003 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY), mock_->code_);
1004 EXPECT_EQ(result, NO_ERROR);
1005
1006 GTEST_LOG_(INFO) << "ReleaseCall_2900 end";
1007 }
1008
1009 /**
1010 * @tc.name: StartUser_3000
1011 * @tc.desc: StartUser
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(AbilityManagerProxyTest, StartUser_3000, TestSize.Level1)
1015 {
1016 GTEST_LOG_(INFO) << "StartUser_3000 start";
1017
1018 sptr<IUserCallback> callback = nullptr;
1019 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1020 .Times(1)
1021 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1022 int32_t result = proxy_->StartUser(1, callback, false);
1023 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER), mock_->code_);
1024 EXPECT_NE(result, NO_ERROR);
1025
1026 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1027 .Times(1)
1028 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1029 sptr<MockIUserCallback> mockIUserCallback = new MockIUserCallback();
1030 mockIUserCallback->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1031 callback = mockIUserCallback;
1032 result = proxy_->StartUser(1, callback, false);
1033 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER), mock_->code_);
1034 EXPECT_EQ(result, NO_ERROR);
1035
1036 GTEST_LOG_(INFO) << "StartUser_3000 end";
1037 }
1038
1039 /**
1040 * @tc.name: StopUser_3100
1041 * @tc.desc: StopUser
1042 * @tc.type: FUNC
1043 */
1044 HWTEST_F(AbilityManagerProxyTest, StopUser_3100, TestSize.Level1)
1045 {
1046 GTEST_LOG_(INFO) << "StopUser_3100 start";
1047
1048 sptr<IUserCallback> callback = nullptr;
1049 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1050 .Times(1)
1051 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1052 int32_t result = proxy_->StopUser(1, callback);
1053 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_USER), mock_->code_);
1054 EXPECT_NE(result, NO_ERROR);
1055
1056 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1057 .Times(1)
1058 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1059 sptr<MockIUserCallback> mockIUserCallback = new MockIUserCallback();
1060 mockIUserCallback->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1061 callback = mockIUserCallback;
1062 result = proxy_->StopUser(1, callback);
1063 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_USER), mock_->code_);
1064 EXPECT_EQ(result, NO_ERROR);
1065
1066 GTEST_LOG_(INFO) << "StopUser_3100 end";
1067 }
1068
1069 /**
1070 * @tc.name: LogoutUser_3200
1071 * @tc.desc: LogoutUser
1072 * @tc.type: FUNC
1073 */
1074 HWTEST_F(AbilityManagerProxyTest, LogoutUser_3200, TestSize.Level1)
1075 {
1076 GTEST_LOG_(INFO) << "LogoutUser_3200 start";
1077
1078 sptr<IUserCallback> callback = nullptr;
1079 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1080 .Times(1)
1081 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1082 int32_t result = proxy_->LogoutUser(1, callback);
1083 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::LOGOUT_USER), mock_->code_);
1084 EXPECT_NE(result, NO_ERROR);
1085
1086 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1087 .Times(1)
1088 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1089 sptr<MockIUserCallback> mockIUserCallback = new MockIUserCallback();
1090 mockIUserCallback->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1091 callback = mockIUserCallback;
1092 result = proxy_->LogoutUser(1, callback);
1093 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::LOGOUT_USER), mock_->code_);
1094 EXPECT_EQ(result, NO_ERROR);
1095
1096 GTEST_LOG_(INFO) << "LogoutUser_3200 end";
1097 }
1098
1099 /**
1100 * @tc.name: SetMissionContinueState_3300
1101 * @tc.desc: SetMissionContinueState
1102 * @tc.type: FUNC
1103 */
1104 HWTEST_F(AbilityManagerProxyTest, SetMissionContinueState_3300, TestSize.Level1)
1105 {
1106 GTEST_LOG_(INFO) << "SetMissionContinueState_3300 start";
1107
1108 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1109 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_ACTIVE;
1110 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1111 .Times(1)
1112 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1113 int32_t result = proxy_->SetMissionContinueState(token, state);
1114 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE), mock_->code_);
1115 EXPECT_NE(result, NO_ERROR);
1116
1117 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1118 .Times(1)
1119 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1120 result = proxy_->SetMissionContinueState(token, state);
1121 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE), mock_->code_);
1122 EXPECT_EQ(result, NO_ERROR);
1123
1124 GTEST_LOG_(INFO) << "SetMissionContinueState_3300 end";
1125 }
1126
1127 #ifdef SUPPORT_SCREEN
1128 /**
1129 * @tc.name: SetMissionLabel_3400
1130 * @tc.desc: SetMissionLabel
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(AbilityManagerProxyTest, SetMissionLabel_3400, TestSize.Level1)
1134 {
1135 GTEST_LOG_(INFO) << "SetMissionLabel_3400 start";
1136
1137 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1138 std::string label = "test";
1139 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1140 .Times(1)
1141 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1142 int32_t result = proxy_->SetMissionLabel(token, label);
1143 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_LABEL), mock_->code_);
1144 EXPECT_NE(result, NO_ERROR);
1145
1146 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1147 .Times(1)
1148 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1149 result = proxy_->SetMissionLabel(token, label);
1150 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_LABEL), mock_->code_);
1151 EXPECT_EQ(result, NO_ERROR);
1152
1153 GTEST_LOG_(INFO) << "SetMissionLabel_3400 end";
1154 }
1155
1156 /**
1157 * @tc.name: SetMissionIcon_3500
1158 * @tc.desc: SetMissionIcon
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(AbilityManagerProxyTest, SetMissionIcon_3500, TestSize.Level1)
1162 {
1163 GTEST_LOG_(INFO) << "SetMissionIcon_3500 start";
1164
1165 int32_t result = proxy_->SetMissionIcon(nullptr, nullptr);
1166 EXPECT_NE(result, NO_ERROR);
1167
1168 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1169 result = proxy_->SetMissionIcon(token, nullptr);
1170 EXPECT_NE(result, NO_ERROR);
1171
1172 GTEST_LOG_(INFO) << "SetMissionIcon_3500 end";
1173 }
1174
1175 /**
1176 * @tc.name: RegisterWindowManagerServiceHandler_3600
1177 * @tc.desc: RegisterWindowManagerServiceHandler
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(AbilityManagerProxyTest, RegisterWindowManagerServiceHandler_3600, TestSize.Level1)
1181 {
1182 GTEST_LOG_(INFO) << "RegisterWindowManagerServiceHandler_3600 start";
1183
1184 int32_t result = proxy_->RegisterWindowManagerServiceHandler(nullptr, false);
1185 EXPECT_NE(result, NO_ERROR);
1186
1187 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1188 .Times(1)
1189 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1190 sptr<MockIWindowManagerServiceHandler> mockIWindowManagerServiceHandler =
1191 new (std::nothrow) MockIWindowManagerServiceHandler();
1192 mockIWindowManagerServiceHandler->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1193 result = proxy_->RegisterWindowManagerServiceHandler(mockIWindowManagerServiceHandler, false);
1194 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_WMS_HANDLER), mock_->code_);
1195 EXPECT_NE(result, NO_ERROR);
1196
1197 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1198 .Times(1)
1199 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1200 result = proxy_->RegisterWindowManagerServiceHandler(mockIWindowManagerServiceHandler, false);
1201 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_WMS_HANDLER), mock_->code_);
1202 EXPECT_EQ(result, NO_ERROR);
1203
1204 GTEST_LOG_(INFO) << "RegisterWindowManagerServiceHandler_3600 end";
1205 }
1206
1207 /**
1208 * @tc.name: PrepareTerminateAbility_3700
1209 * @tc.desc: PrepareTerminateAbility
1210 * @tc.type: FUNC
1211 */
1212 HWTEST_F(AbilityManagerProxyTest, PrepareTerminateAbility_3700, TestSize.Level1)
1213 {
1214 GTEST_LOG_(INFO) << "PrepareTerminateAbility_3700 start";
1215
1216 sptr<IPrepareTerminateCallback> callback = nullptr;
1217 int32_t result = proxy_->PrepareTerminateAbility(nullptr, callback);
1218 EXPECT_NE(result, NO_ERROR);
1219
1220 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1221 .Times(1)
1222 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1223 sptr<IRemoteObject> token = nullptr;
1224 sptr<MockIPrepareTerminateCallback> mockIPrepareTerminateCallback =
1225 new (std::nothrow) MockIPrepareTerminateCallback();
1226 mockIPrepareTerminateCallback->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1227 callback = mockIPrepareTerminateCallback;
1228 result = proxy_->PrepareTerminateAbility(token, callback);
1229 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::PREPARE_TERMINATE_ABILITY), mock_->code_);
1230 EXPECT_NE(result, NO_ERROR);
1231
1232 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1233 .Times(1)
1234 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1235 token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1236 result = proxy_->PrepareTerminateAbility(token, callback);
1237 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::PREPARE_TERMINATE_ABILITY), mock_->code_);
1238 EXPECT_EQ(result, NO_ERROR);
1239
1240 GTEST_LOG_(INFO) << "PrepareTerminateAbility_3700 end";
1241 }
1242
1243 /**
1244 * @tc.name: GetDialogSessionInfo_3800
1245 * @tc.desc: GetDialogSessionInfo
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(AbilityManagerProxyTest, GetDialogSessionInfo_3800, TestSize.Level1)
1249 {
1250 GTEST_LOG_(INFO) << "GetDialogSessionInfo_3800 start";
1251
1252 std::string dialogSessionId = "test";
1253 sptr<DialogSessionInfo> info = nullptr;
1254 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1255 .Times(1)
1256 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1257 int32_t result = proxy_->GetDialogSessionInfo(dialogSessionId, info);
1258 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_DIALOG_SESSION_INFO), mock_->code_);
1259 EXPECT_NE(result, NO_ERROR);
1260
1261 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1262 .Times(1)
1263 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1264 result = proxy_->GetDialogSessionInfo(dialogSessionId, info);
1265 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_DIALOG_SESSION_INFO), mock_->code_);
1266 EXPECT_NE(result, NO_ERROR);
1267
1268 GTEST_LOG_(INFO) << "GetDialogSessionInfo_3800 end";
1269 }
1270
1271 /**
1272 * @tc.name: SendDialogResult_3900
1273 * @tc.desc: SendDialogResult
1274 * @tc.type: FUNC
1275 */
1276 HWTEST_F(AbilityManagerProxyTest, SendDialogResult_3900, TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) << "SendDialogResult_3900 start";
1279
1280 Want want;
1281 std::string dialogSessionId = "test";
1282 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1283 .Times(1)
1284 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1285 int32_t result = proxy_->SendDialogResult(want, dialogSessionId, false);
1286 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_DIALOG_RESULT), mock_->code_);
1287 EXPECT_NE(result, NO_ERROR);
1288
1289 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1290 .Times(1)
1291 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1292 result = proxy_->SendDialogResult(want, dialogSessionId, false);
1293 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_DIALOG_RESULT), mock_->code_);
1294 EXPECT_EQ(result, NO_ERROR);
1295
1296 GTEST_LOG_(INFO) << "SendDialogResult_3900 end";
1297 }
1298
1299 /**
1300 * @tc.name: RegisterAbilityFirstFrameStateObserver_4000
1301 * @tc.desc: RegisterAbilityFirstFrameStateObserver
1302 * @tc.type: FUNC
1303 */
1304 HWTEST_F(AbilityManagerProxyTest, RegisterAbilityFirstFrameStateObserver_4000, TestSize.Level1)
1305 {
1306 GTEST_LOG_(INFO) << "RegisterAbilityFirstFrameStateObserver_4000 start";
1307
1308 sptr<IAbilityFirstFrameStateObserver> observer = nullptr;
1309 std::string targetBundleName = "test";
1310
1311 int32_t result = proxy_->RegisterAbilityFirstFrameStateObserver(observer, targetBundleName);
1312 EXPECT_NE(result, NO_ERROR);
1313
1314 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1315 .Times(1)
1316 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
1317 sptr<MockIAbilityFirstFrameStateObserver> mockIAbilityFirstFrameStateObserver =
1318 new (std::nothrow) MockIAbilityFirstFrameStateObserver();
1319 mockIAbilityFirstFrameStateObserver->iremoteObject_ = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1320 observer = mockIAbilityFirstFrameStateObserver;
1321 result = proxy_->RegisterAbilityFirstFrameStateObserver(observer, targetBundleName);
1322 EXPECT_EQ(
1323 static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_ABILITY_FIRST_FRAME_STATE_OBSERVER), mock_->code_);
1324 EXPECT_NE(result, NO_ERROR);
1325
1326 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1327 .Times(1)
1328 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1329 result = proxy_->RegisterAbilityFirstFrameStateObserver(observer, targetBundleName);
1330 EXPECT_EQ(
1331 static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_ABILITY_FIRST_FRAME_STATE_OBSERVER), mock_->code_);
1332 EXPECT_EQ(result, NO_ERROR);
1333
1334 GTEST_LOG_(INFO) << "RegisterAbilityFirstFrameStateObserver_4000 end";
1335 }
1336 #endif
1337 } // namespace AAFwk
1338 } // namespace OHOS
1339