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_proxy.h"
19 #include "free_install_observer_manager.h"
20 #include "iacquire_share_data_callback_interface.h"
21 #include "iability_manager_collaborator.h"
22 #include "status_bar_delegate_interface.h"
23
24 #include "ability_manager_errors.h"
25 #include "ability_manager_stub_mock.h"
26 #include "mock_ability_connect_callback.h"
27 #include "mock_ability_token.h"
28 #include "ability_scheduler_mock.h"
29 #include "ability_record.h"
30 #include "app_debug_listener_stub_mock.h"
31 #include "ability_scheduler.h"
32 #include "hilog_tag_wrapper.h"
33 #include "mission_snapshot.h"
34 #include "want_sender_info.h"
35 #include "pending_want_record.h"
36
37
38 using namespace testing::ext;
39 using namespace testing;
40 using namespace OHOS::AppExecFwk;
41
42 namespace OHOS {
43 namespace AAFwk {
44 namespace {
45 const int USER_ID = 100;
46 constexpr int32_t REPLY_RESULT = 1;
47 } // namespace
48
49 class IFreeInstallObserverMock : public IFreeInstallObserver {
50 public:
51 IFreeInstallObserverMock() = default;
52 virtual ~IFreeInstallObserverMock() = default;
OnInstallFinished(const std::string & bundleName,const std::string & abilityName,const std::string & startTime,int32_t resultCode)53 void OnInstallFinished(const std::string &bundleName, const std::string &abilityName,
54 const std::string &startTime, int32_t resultCode) override {};
55
OnInstallFinishedByUrl(const std::string & startTime,const std::string & url,int32_t resultCode)56 void OnInstallFinishedByUrl(const std::string &startTime, const std::string &url,
57 int32_t resultCode) override {};
AsObject()58 sptr<IRemoteObject> AsObject() override
59 {
60 AbilityRequest abilityRequest;
61 abilityRequest.appInfo.bundleName = "data.client.bundle";
62 abilityRequest.abilityInfo.name = "ClientAbility";
63 abilityRequest.abilityInfo.type = AbilityType::DATA;
64 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
65 return abilityRecord->GetToken();
66 };
67 };
68
69 class IAcquireShareDataCallbackMock : public IAcquireShareDataCallback {
70 public:
71 IAcquireShareDataCallbackMock() = default;
72 virtual ~IAcquireShareDataCallbackMock() = default;
AcquireShareDataDone(int32_t resultCode,WantParams & wantParam)73 int32_t AcquireShareDataDone(int32_t resultCode, WantParams &wantParam) override { return 0; };
AsObject()74 sptr<IRemoteObject> AsObject() override
75 {
76 AbilityRequest abilityRequest;
77 abilityRequest.appInfo.bundleName = "data.client.bundle";
78 abilityRequest.abilityInfo.name = "ClientAbility";
79 abilityRequest.abilityInfo.type = AbilityType::DATA;
80 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
81 return abilityRecord->GetToken();
82 };
83 };
84
85 class MockAbilityManagerCollaborator : public IAbilityManagerCollaborator {
86 public:
87 MOCK_METHOD5(NotifyStartAbility, int32_t(const AppExecFwk::AbilityInfo &abilityInfo,
88 int32_t userId, Want &want, uint64_t accessTokenIDEx, int32_t windowMode));
89 MOCK_METHOD1(NotifyPreloadAbility, int32_t(const std::string &bundleName));
90 MOCK_METHOD2(NotifyMissionCreated, int32_t(int32_t missionId, const Want &want));
91 MOCK_METHOD1(NotifyMissionCreated, int32_t(const sptr<SessionInfo> &sessionInfo));
92 MOCK_METHOD3(NotifyLoadAbility, int32_t(const AppExecFwk::AbilityInfo &abilityInfo, int32_t missionId,
93 const Want &want));
94 MOCK_METHOD2(NotifyLoadAbility, int32_t(const AppExecFwk::AbilityInfo &abilityInfo,
95 const sptr<SessionInfo> &sessionInfo));
96 MOCK_METHOD1(NotifyMoveMissionToBackground, int32_t(int32_t missionId));
97 MOCK_METHOD1(NotifyMoveMissionToForeground, int32_t(int32_t missionId));
98 MOCK_METHOD1(NotifyTerminateMission, int32_t(int32_t missionId));
99 MOCK_METHOD1(NotifyClearMission, int32_t(int32_t missionId));
100 MOCK_METHOD3(NotifyRemoveShellProcess, int32_t(int32_t pid, int32_t type, const std::string &reason));
101 MOCK_METHOD1(UpdateMissionInfo, void(sptr<SessionInfo> &sessionInfo));
AsObject()102 sptr<IRemoteObject> AsObject() override
103 {
104 WindowConfig windowConfig;
105 AbilityRequest abilityRequest;
106 abilityRequest.appInfo.bundleName = "data.client.bundle";
107 abilityRequest.abilityInfo.name = "ClientAbility";
108 abilityRequest.abilityInfo.type = AbilityType::DATA;
109 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
110 return abilityRecord->GetToken();
111 }
112 };
113
114 class MockIStatusBarDelegate : public IStatusBarDelegate {
115 public:
116 MockIStatusBarDelegate() = default;
117 virtual ~MockIStatusBarDelegate() = default;
CheckIfStatusBarItemExists(uint32_t accessTokenId,const std::string & instanceKey,bool & isExist)118 int32_t CheckIfStatusBarItemExists(uint32_t accessTokenId, const std::string &instanceKey,
119 bool& isExist) override { return 0; };
AttachPidToStatusBarItem(uint32_t accessTokenId,int32_t pid,const std::string & instanceKey)120 int32_t AttachPidToStatusBarItem(uint32_t accessTokenId, int32_t pid,
121 const std::string &instanceKey) override { return 0; };
DetachPidToStatusBarItem(uint32_t accessTokenId,int32_t pid,const std::string & instanceKey)122 int32_t DetachPidToStatusBarItem(uint32_t accessTokenId, int32_t pid,
123 const std::string &instanceKey) override { return 0; };
AsObject()124 sptr<IRemoteObject> AsObject() override
125 {
126 AbilityRequest abilityRequest;
127 abilityRequest.appInfo.bundleName = "data.client.bundle";
128 abilityRequest.abilityInfo.name = "ClientAbility";
129 abilityRequest.abilityInfo.type = AbilityType::DATA;
130 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
131 return abilityRecord->GetToken();
132 };
133 };
134 class AbilityManagerProxySecondTest : public testing::Test {
135 public:
136 static void SetUpTestCase(void);
137 static void TearDownTestCase(void);
138 void SetUp();
139 void TearDown();
140
141 std::shared_ptr<AbilityManagerProxy> proxy_{ nullptr };
142 sptr<AbilityManagerStubMock> mock_{ nullptr };
143 };
144
SetUpTestCase(void)145 void AbilityManagerProxySecondTest::SetUpTestCase(void)
146 {}
TearDownTestCase(void)147 void AbilityManagerProxySecondTest::TearDownTestCase(void)
148 {}
TearDown()149 void AbilityManagerProxySecondTest::TearDown()
150 {}
151
SetUp()152 void AbilityManagerProxySecondTest::SetUp()
153 {
154 mock_ = new AbilityManagerStubMock();
155 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
156 }
157
158 /**
159 * @tc.name: AbilityManagerProxy_AbilityWindowConfigTransitionDone_0100
160 * @tc.desc: AbilityWindowConfigTransitionDone
161 * @tc.type: FUNC
162 */
163 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_AbilityWindowConfigTransitionDone_0100, TestSize.Level1)
164 {
165 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AbilityWindowConfigTransitionDone_0100 start");
166 WindowConfig windowConfig;
167 AbilityRequest abilityRequest;
168 abilityRequest.appInfo.bundleName = "data.client.bundle";
169 abilityRequest.abilityInfo.name = "ClientAbility";
170 abilityRequest.abilityInfo.type = AbilityType::DATA;
171 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
172 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
173 EXPECT_EQ(proxy_->AbilityWindowConfigTransitionDone(abilityRecord->GetToken(), windowConfig),
174 INVALID_PARAMETERS_ERR);
175 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
176 EXPECT_EQ(proxy_->AbilityWindowConfigTransitionDone(abilityRecord->GetToken(), windowConfig), 0);
177 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AbilityWindowConfigTransitionDone_0100 end");
178 }
179
180 /**
181 * @tc.name: AbilityManagerProxy_ScheduleDisconnectAbilityDonee_0100
182 * @tc.desc: ScheduleDisconnectAbilityDone
183 * @tc.type: FUNC
184 */
185 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ScheduleDisconnectAbilityDonee_0100, TestSize.Level1)
186 {
187 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleDisconnectAbilityDonee_0100 start");
188 AbilityRequest abilityRequest;
189 abilityRequest.appInfo.bundleName = "data.client.bundle";
190 abilityRequest.abilityInfo.name = "ClientAbility";
191 abilityRequest.abilityInfo.type = AbilityType::DATA;
192 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
193 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
194 EXPECT_EQ(proxy_->ScheduleDisconnectAbilityDone(abilityRecord->GetToken()), INVALID_PARAMETERS_ERR);
195 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
196 EXPECT_EQ(proxy_->ScheduleDisconnectAbilityDone(abilityRecord->GetToken()), 0);
197 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleDisconnectAbilityDonee_0100 end");
198 }
199
200 /**
201 * @tc.name: AbilityManagerProxy_ScheduleCommandAbilityDone_0100
202 * @tc.desc: ScheduleCommandAbilityDone
203 * @tc.type: FUNC
204 */
205 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ScheduleCommandAbilityDone_0100, TestSize.Level1)
206 {
207 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleCommandAbilityDone_0100 start");
208 AbilityRequest abilityRequest;
209 abilityRequest.appInfo.bundleName = "data.client.bundle";
210 abilityRequest.abilityInfo.name = "ClientAbility";
211 abilityRequest.abilityInfo.type = AbilityType::DATA;
212 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
213 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
214 EXPECT_EQ(proxy_->ScheduleCommandAbilityDone(abilityRecord->GetToken()), INVALID_PARAMETERS_ERR);
215 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
216 EXPECT_EQ(proxy_->ScheduleCommandAbilityDone(abilityRecord->GetToken()), 0);
217 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleCommandAbilityDone_0100 end");
218 }
219
220 /**
221 * @tc.name: AbilityManagerProxy_ScheduleCommandAbilityWindowDone_0100
222 * @tc.desc: ScheduleCommandAbilityWindowDone
223 * @tc.type: FUNC
224 */
225 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ScheduleCommandAbilityWindowDone_0100, TestSize.Level1)
226 {
227 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleCommandAbilityWindowDone_0100 start");
228 AbilityRequest abilityRequest;
229 abilityRequest.appInfo.bundleName = "data.client.bundle";
230 abilityRequest.abilityInfo.name = "ClientAbility";
231 abilityRequest.abilityInfo.type = AbilityType::DATA;
232 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
233 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
234 sptr<SessionInfo> session = new (std::nothrow) SessionInfo();
235 EXPECT_EQ(proxy_->ScheduleCommandAbilityWindowDone(abilityRecord->GetToken(),
236 session, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND), INVALID_PARAMETERS_ERR);
237 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
238 EXPECT_EQ(proxy_->ScheduleCommandAbilityWindowDone(abilityRecord->GetToken(),
239 session, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND), 0);
240 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ScheduleCommandAbilityWindowDone_0100 end");
241 }
242
243 /**
244 * @tc.name: AbilityManagerProxy_StopServiceAbility_0100
245 * @tc.desc: StopServiceAbilit
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_StopServiceAbility_0100, TestSize.Level1)
249 {
250 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StopServiceAbility_0100 start");
251 AbilityRequest abilityRequest;
252 abilityRequest.appInfo.bundleName = "data.client.bundle";
253 abilityRequest.abilityInfo.name = "ClientAbility";
254 abilityRequest.abilityInfo.type = AbilityType::DATA;
255 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
256 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
257 const Want want;
258 EXPECT_EQ(proxy_->StopServiceAbility(want, -1, abilityRecord->GetToken()), INVALID_PARAMETERS_ERR);
259 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
260 EXPECT_EQ(proxy_->StopServiceAbility(want, -1, abilityRecord->GetToken()), NO_ERROR);
261 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_StopServiceAbility_0100 end");
262 }
263
264 /**
265 * @tc.name: AbilityManagerProxy_GetTopAbility_0100
266 * @tc.desc: GetTopAbility
267 * @tc.type: FUNC
268 */
269 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetTopAbility_0100, TestSize.Level1)
270 {
271 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetTopAbility_0100 start");
272 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
273 sptr<IRemoteObject> token = nullptr;
274 EXPECT_EQ(proxy_->GetTopAbility(token), INVALID_PARAMETERS_ERR);
275 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
276 EXPECT_EQ(proxy_->GetTopAbility(token), ERR_UNKNOWN_OBJECT);
277 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetTopAbility_0100 end");
278 }
279
280 /**
281 * @tc.name: AbilityManagerProxy_GetElementNameByToken_0100
282 * @tc.desc: GetElementNameByToken
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetElementNameByToken_0100, TestSize.Level1)
286 {
287 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetElementNameByToken_0100 start");
288 AbilityRequest abilityRequest;
289 abilityRequest.appInfo.bundleName = "data.client.bundle";
290 abilityRequest.abilityInfo.name = "ClientAbility";
291 abilityRequest.abilityInfo.type = AbilityType::DATA;
292 bool isNeedLocalDeviceId = true;
293 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
294 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
295 proxy_->GetElementNameByToken(abilityRecord->GetToken(), isNeedLocalDeviceId);
296 EXPECT_NE(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ELEMENT_NAME_BY_TOKEN), mock_->code_);
297 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
298 .Times(1)
299 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
300 proxy_->GetElementNameByToken(abilityRecord->GetToken(), isNeedLocalDeviceId);
301 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ELEMENT_NAME_BY_TOKEN), mock_->code_);
302 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetElementNameByToken_0100 end");
303 }
304
305 #ifdef ABILITY_COMMAND_FOR_TEST
306 /**
307 * @tc.name: AbilityManagerProxy_ForceTimeoutForTest_0100
308 * @tc.desc: ForceTimeoutForTest
309 * @tc.type: FUNC
310 */
311 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ForceTimeoutForTest_0100, TestSize.Level1)
312 {
313 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ForceTimeoutForTest_0100 start");
314 std::string abilityName = "";
315 std::string state = "";
316 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
317 EXPECT_EQ(proxy_->ForceTimeoutForTest(abilityName, state), INVALID_PARAMETERS_ERR);
318 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
319 EXPECT_EQ(proxy_->ForceTimeoutForTest(abilityName, state), NO_ERROR);
320 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ForceTimeoutForTest_0100 end");
321 }
322 #endif
323
324 /**
325 * @tc.name: AbilityManagerProxy_UninstallApp_0100
326 * @tc.desc: UninstallApp
327 * @tc.type: FUNC
328 */
329 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_UninstallApp_0100, TestSize.Level1)
330 {
331 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UninstallApp_0100 start");
332 std::string bundleName = "";
333 int32_t uid = 0;
334 int32_t appIndex = 0;
335 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
336 EXPECT_EQ(proxy_->UninstallApp(bundleName, uid, appIndex), INVALID_PARAMETERS_ERR);
337 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
338 EXPECT_EQ(proxy_->UninstallApp(bundleName, uid, appIndex), NO_ERROR);
339 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UninstallApp_0100 end");
340 }
341
342 /**
343 * @tc.name: AbilityManagerProxy_UpgradeApp_0100
344 * @tc.desc: UpgradeApp
345 * @tc.type: FUNC
346 */
347 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_UpgradeApp_0100, TestSize.Level1)
348 {
349 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UpgradeApp_0100 start");
350 std::string bundleName = "";
351 int32_t uid = 0;
352 std::string exitMsg = "";
353 int32_t appIndex = 0;
354 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
355 EXPECT_EQ(proxy_->UpgradeApp(bundleName, uid, exitMsg, appIndex), INVALID_PARAMETERS_ERR);
356 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
357 EXPECT_EQ(proxy_->UpgradeApp(bundleName, uid, exitMsg, appIndex), NO_ERROR);
358 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UpgradeApp_0100 end");
359 }
360
361 /**
362 * @tc.name: AbilityManagerProxy_SendWantSender_0100
363 * @tc.desc: SendWantSende
364 * @tc.type: FUNC
365 */
366 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_SendWantSender_0100, TestSize.Level1)
367 {
368 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SendWantSender_0100 start");
369 sptr<IWantSender> target(new (std::nothrow) PendingWantRecord());
370 SenderInfo senderInf;
371 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
372 EXPECT_EQ(proxy_->SendWantSender(target, senderInf), INVALID_PARAMETERS_ERR);
373 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
374 EXPECT_EQ(proxy_->SendWantSender(target, senderInf), INNER_ERR);
375 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SendWantSender_0100 end");
376 }
377
378 /**
379 * @tc.name: AbilityManagerProxy_GetWantSender_0100
380 * @tc.desc: GetWantSender
381 * @tc.type: FUNC
382 */
383 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetWantSender_0100, TestSize.Level1)
384 {
385 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetWantSender_0100 start");
386 WantSenderInfo wantSenderInfo;
387 sptr<IRemoteObject> callerToken = nullptr;
388 int32_t uid = 0;
389 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
390 EXPECT_EQ(proxy_->GetWantSender(wantSenderInfo, callerToken, uid), nullptr);
391 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
392 EXPECT_EQ(proxy_->GetWantSender(wantSenderInfo, callerToken, uid), nullptr);
393 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetWantSender_0100 end");
394 }
395
396 /**
397 * @tc.name: AbilityManagerProxy_GetPendingWantUid_0100
398 * @tc.desc: GetPendingWantUid
399 * @tc.type: FUNC
400 */
401 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetPendingWantUid_0100, TestSize.Level1)
402 {
403 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetPendingWantUid_0100 start");
404 sptr<IWantSender> target(new (std::nothrow) PendingWantRecord());
405 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
406 EXPECT_EQ(proxy_->GetPendingWantUid(target), INNER_ERR);
407 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
408 EXPECT_EQ(proxy_->GetPendingWantUid(target), NO_ERROR);
409 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetPendingWantUid_0100 end");
410 }
411
412 /**
413 * @tc.name: AbilityManagerProxy_GetPendingWantUserId_0100
414 * @tc.desc: GetPendingWantUserId
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetPendingWantUserId_0100, TestSize.Level1)
418 {
419 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetPendingWantUserId_0100 start");
420 sptr<IWantSender> target(new (std::nothrow) PendingWantRecord());
421 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
422 EXPECT_EQ(proxy_->GetPendingWantUserId(target), INNER_ERR);
423 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
424 EXPECT_EQ(proxy_->GetPendingWantUserId(target), NO_ERROR);
425 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetPendingWantUserId_0100 end");
426 }
427
428 /**
429 * @tc.name: AbilityManagerProxy_GetMissionIdByToken_0100
430 * @tc.desc: GetMissionIdByToken
431 * @tc.type: FUNC
432 */
433 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetMissionIdByToken_0100, TestSize.Level1)
434 {
435 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetMissionIdByToken_0100 start");
436 AbilityRequest abilityRequest;
437 abilityRequest.appInfo.bundleName = "data.client.bundle";
438 abilityRequest.abilityInfo.name = "ClientAbility";
439 abilityRequest.abilityInfo.type = AbilityType::DATA;
440 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
441 sptr<IRemoteObject> token = nullptr;
442 EXPECT_EQ(proxy_->GetMissionIdByToken(token), -1);
443 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
444 EXPECT_EQ(proxy_->GetMissionIdByToken(abilityRecord->GetToken()), -1);
445 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
446 proxy_->GetMissionIdByToken(abilityRecord->GetToken());
447 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetMissionIdByToken_0100 end");
448 }
449
450 /**
451 * @tc.name: AbilityManagerProxy_FreeInstallAbilityFromRemote_0100
452 * @tc.desc: FreeInstallAbilityFromRemote
453 * @tc.type: FUNC
454 */
455 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_FreeInstallAbilityFromRemote_0100, TestSize.Level1)
456 {
457 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_FreeInstallAbilityFromRemote_0100 start");
458 AbilityRequest abilityRequest;
459 abilityRequest.appInfo.bundleName = "data.client.bundle";
460 abilityRequest.abilityInfo.name = "ClientAbility";
461 abilityRequest.abilityInfo.type = AbilityType::DATA;
462 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
463 Want want;
464 sptr<IRemoteObject> callback = abilityRecord->GetToken();
465 int32_t userId = 0;
466 int requestCode = 0;
467 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
468 EXPECT_EQ(proxy_->FreeInstallAbilityFromRemote(want, callback, userId, requestCode), INVALID_PARAMETERS_ERR);
469 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
470 proxy_->FreeInstallAbilityFromRemote(want, callback, userId, requestCode);
471 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_FreeInstallAbilityFromRemote_0100 end");
472 }
473
474 /**
475 * @tc.name: AbilityManagerProxy_AddFreeInstallObserver_0100
476 * @tc.desc: AddFreeInstallObserver
477 * @tc.type: FUNC
478 */
479 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_AddFreeInstallObserver_0100, TestSize.Level1)
480 {
481 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AddFreeInstallObserver_0100 start");
482 AbilityRequest abilityRequest;
483 abilityRequest.appInfo.bundleName = "data.client.bundle";
484 abilityRequest.abilityInfo.name = "ClientAbility";
485 abilityRequest.abilityInfo.type = AbilityType::DATA;
486 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
487 Want want;
488 sptr<IRemoteObject> callback = abilityRecord->GetToken();
489 sptr<AbilityRuntime::IFreeInstallObserver> observer = nullptr;
490 EXPECT_EQ(proxy_->AddFreeInstallObserver(callback, observer), INNER_ERR);
491 observer = new IFreeInstallObserverMock();
492 callback = nullptr;
493 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
494 EXPECT_EQ(proxy_->AddFreeInstallObserver(callback, observer), INVALID_PARAMETERS_ERR);
495 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
496 proxy_->AddFreeInstallObserver(callback, observer);
497 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AddFreeInstallObserver_0100 end");
498 }
499
500 /**
501 * @tc.name: AbilityManagerProxy_DumpAbilityInfoDone_0100
502 * @tc.desc: DumpAbilityInfoDone
503 * @tc.type: FUNC
504 */
505 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_DumpAbilityInfoDone_0100, TestSize.Level1)
506 {
507 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DumpAbilityInfoDone_0100 start");
508 AbilityRequest abilityRequest;
509 abilityRequest.appInfo.bundleName = "data.client.bundle";
510 abilityRequest.abilityInfo.name = "ClientAbility";
511 abilityRequest.abilityInfo.type = AbilityType::DATA;
512 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
513 std::vector<std::string> infos;
514 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
515 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
516 EXPECT_EQ(proxy_->DumpAbilityInfoDone(infos, callerToken), INVALID_PARAMETERS_ERR);
517 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
518 proxy_->DumpAbilityInfoDone(infos, callerToken);
519 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DumpAbilityInfoDone_0100 end");
520 }
521
522 /**
523 * @tc.name: AbilityManagerProxy_IsValidMissionIds_0100
524 * @tc.desc: IsValidMissionIds
525 * @tc.type: FUNC
526 */
527 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_IsValidMissionIds_0100, TestSize.Level1)
528 {
529 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_IsValidMissionIds_0100 start");
530 std::vector<int32_t> missionIds;
531 std::vector<MissionValidResult> results;
532 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
533 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), INVALID_PARAMETERS_ERR);
534 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
535 proxy_->IsValidMissionIds(missionIds, results);
536 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_IsValidMissionIds_0100 end");
537 }
538
539 /**
540 * @tc.name: AbilityManagerProxy_VerifyPermission_0100
541 * @tc.desc: VerifyPermission
542 * @tc.type: FUNC
543 */
544 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_VerifyPermission_0100, TestSize.Level1)
545 {
546 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_VerifyPermission_0100 start");
547 std::string permission = "";
548 int pid = 0;
549 int uid = 0;
550 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
551 EXPECT_EQ(proxy_->VerifyPermission(permission, pid, uid), INVALID_PARAMETERS_ERR);
552 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
553 proxy_->VerifyPermission(permission, pid, uid);
554 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_VerifyPermission_0100 end");
555 }
556
557 /**
558 * @tc.name: AbilityManagerProxy_ReportDrawnCompleted_0100
559 * @tc.desc: ReportDrawnCompleted
560 * @tc.type: FUNC
561 */
562 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ReportDrawnCompleted_0100, TestSize.Level1)
563 {
564 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ReportDrawnCompleted_0100 start");
565 AbilityRequest abilityRequest;
566 abilityRequest.appInfo.bundleName = "data.client.bundle";
567 abilityRequest.abilityInfo.name = "ClientAbility";
568 abilityRequest.abilityInfo.type = AbilityType::DATA;
569 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
570 sptr<IRemoteObject> callerToken = nullptr;
571 EXPECT_EQ(proxy_->ReportDrawnCompleted(callerToken), INNER_ERR);
572 callerToken = abilityRecord->GetToken();
573 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
574 EXPECT_EQ(proxy_->ReportDrawnCompleted(callerToken), INVALID_PARAMETERS_ERR);
575 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
576 proxy_->ReportDrawnCompleted(callerToken);
577 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ReportDrawnCompleted_0100 end");
578 }
579
580 /**
581 * @tc.name: AbilityManagerProxy_RequestDialogService_0100
582 * @tc.desc: RequestDialogService
583 * @tc.type: FUNC
584 */
585 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RequestDialogService_0100, TestSize.Level1)
586 {
587 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RequestDialogService_0100 start");
588 AbilityRequest abilityRequest;
589 abilityRequest.appInfo.bundleName = "data.client.bundle";
590 abilityRequest.abilityInfo.name = "ClientAbility";
591 abilityRequest.abilityInfo.type = AbilityType::DATA;
592 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
593 sptr<IRemoteObject> callerToken = nullptr;
594 Want want;
595 EXPECT_EQ(proxy_->RequestDialogService(want, callerToken), ERR_INVALID_CALLER);
596 callerToken = abilityRecord->GetToken();
597 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
598 EXPECT_EQ(proxy_->RequestDialogService(want, callerToken), INVALID_PARAMETERS_ERR);
599 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
600 proxy_->RequestDialogService(want, callerToken);
601 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RequestDialogService_0100 end");
602 }
603
604 /**
605 * @tc.name: AbilityManagerProxy_AcquireShareData_0100
606 * @tc.desc: AcquireShareData
607 * @tc.type: FUNC
608 */
609 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_AcquireShareData_0100, TestSize.Level1)
610 {
611 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AcquireShareData_0100 start");
612 int32_t missionId = 0;
613 EXPECT_EQ(proxy_->AcquireShareData(missionId, nullptr), INNER_ERR);
614 sptr<IAcquireShareDataCallback> shareData = new IAcquireShareDataCallbackMock();
615 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
616 EXPECT_EQ(proxy_->AcquireShareData(missionId, shareData), INNER_ERR);
617 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
618 proxy_->AcquireShareData(missionId, shareData);
619 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_AcquireShareData_0100 end");
620 }
621
622 /**
623 * @tc.name: AbilityManagerProxy_ShareDataDone_0100
624 * @tc.desc: ShareDataDone
625 * @tc.type: FUNC
626 */
627 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ShareDataDone_0100, TestSize.Level1)
628 {
629 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ShareDataDone_0100 start");
630 AbilityRequest abilityRequest;
631 abilityRequest.appInfo.bundleName = "data.client.bundle";
632 abilityRequest.abilityInfo.name = "ClientAbility";
633 abilityRequest.abilityInfo.type = AbilityType::DATA;
634 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
635 sptr<IRemoteObject> token = abilityRecord->GetToken();
636 int32_t resultCode = 0;
637 int32_t uniqueId = 0;
638 WantParams wantParam;
639 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
640 EXPECT_EQ(proxy_->ShareDataDone(token, resultCode, uniqueId, wantParam), INVALID_PARAMETERS_ERR);
641 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
642 proxy_->ShareDataDone(token, resultCode, uniqueId, wantParam);
643 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ShareDataDone_0100 end");
644 }
645
646 /**
647 * @tc.name: AbilityManagerProxy_ForceExitApp_0100
648 * @tc.desc: ForceExitApp
649 * @tc.type: FUNC
650 */
651 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_ForceExitApp_0100, TestSize.Level1)
652 {
653 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ForceExitApp_0100 start");
654 int32_t pid = 0;
655 ExitReason exitReason;
656 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
657 EXPECT_EQ(proxy_->ForceExitApp(pid, exitReason), INVALID_PARAMETERS_ERR);
658 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
659 proxy_->ForceExitApp(pid, exitReason);
660 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_ForceExitApp_0100 end");
661 }
662
663 /**
664 * @tc.name: AbilityManagerProxy_RecordAppExitReason_0100
665 * @tc.desc: RecordAppExitReason
666 * @tc.type: FUNC
667 */
668 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RecordAppExitReason_0100, TestSize.Level1)
669 {
670 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordAppExitReason_0100 start");
671 ExitReason exitReason;
672 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
673 EXPECT_EQ(proxy_->RecordAppExitReason(exitReason), INVALID_PARAMETERS_ERR);
674 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
675 proxy_->RecordAppExitReason(exitReason);
676 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordAppExitReason_0100 end");
677 }
678
679 /**
680 * @tc.name: AbilityManagerProxy_RecordProcessExitReason_0100
681 * @tc.desc: RecordProcessExitReason
682 * @tc.type: FUNC
683 */
684 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RecordProcessExitReason_0100, TestSize.Level1)
685 {
686 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordProcessExitReason_0100 start");
687 ExitReason exitReason;
688 int32_t pid = 0;
689 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
690 EXPECT_EQ(proxy_->RecordProcessExitReason(pid, exitReason), INVALID_PARAMETERS_ERR);
691 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
692 proxy_->RecordProcessExitReason(pid, exitReason);
693 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordProcessExitReason_0100 end");
694 }
695
696 /**
697 * @tc.name: AbilityManagerProxy_RecordProcessExitReason_0200
698 * @tc.desc: RecordProcessExitReason
699 * @tc.type: FUNC
700 */
701 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RecordProcessExitReason_0200, TestSize.Level1)
702 {
703 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordProcessExitReason_0200 start");
704 ExitReason exitReason;
705 int32_t pid = 0;
706 int32_t uid = 0;
707 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
708 EXPECT_EQ(proxy_->RecordProcessExitReason(pid, uid, exitReason), INVALID_PARAMETERS_ERR);
709 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
710 proxy_->RecordProcessExitReason(pid, uid, exitReason);
711 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RecordProcessExitReason_0200 end");
712 }
713
714 /**
715 * @tc.name: AbilityManagerProxy_NotifySaveAsResult_0100
716 * @tc.desc: NotifySaveAsResult
717 * @tc.type: FUNC
718 */
719 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_NotifySaveAsResult_0100, TestSize.Level1)
720 {
721 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_NotifySaveAsResult_0100 start");
722 Want want;
723 int resultCode = 0;
724 int requestCode = 0;
725 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
726 EXPECT_EQ(proxy_->NotifySaveAsResult(want, resultCode, requestCode), 0);
727 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
728 proxy_->NotifySaveAsResult(want, resultCode, requestCode);
729 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_NotifySaveAsResult_0100 end");
730 }
731
732 /**
733 * @tc.name: AbilityManagerProxy_SetSessionManagerService_0100
734 * @tc.desc: SetSessionManagerService
735 * @tc.type: FUNC
736 */
737 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_SetSessionManagerService_0100, TestSize.Level1)
738 {
739 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SetSessionManagerService_0100 start");
740 AbilityRequest abilityRequest;
741 abilityRequest.appInfo.bundleName = "data.client.bundle";
742 abilityRequest.abilityInfo.name = "ClientAbility";
743 abilityRequest.abilityInfo.type = AbilityType::DATA;
744 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
745 sptr<IRemoteObject> sessionManagerService = abilityRecord->GetToken();
746 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
747 EXPECT_EQ(proxy_->SetSessionManagerService(sessionManagerService), INVALID_PARAMETERS_ERR);
748 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
749 proxy_->SetSessionManagerService(sessionManagerService);
750 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_SetSessionManagerService_0100 end");
751 }
752
753 /**
754 * @tc.name: AbilityManagerProxy_RegisterIAbilityManagerCollaborator_0100
755 * @tc.desc: RegisterIAbilityManagerCollaborator
756 * @tc.type: FUNC
757 */
758 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RegisterIAbilityManagerCollaborator_0100, TestSize.Level1)
759 {
760 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RegisterIAbilityManagerCollaborator_0100 start");
761 int32_t type = 0;
762 sptr<IAbilityManagerCollaborator> impl = nullptr;
763 EXPECT_EQ(proxy_->RegisterIAbilityManagerCollaborator(type, impl), ERR_INVALID_VALUE);
764 impl = new (std::nothrow) MockAbilityManagerCollaborator();
765 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
766 EXPECT_EQ(proxy_->RegisterIAbilityManagerCollaborator(type, impl), INVALID_PARAMETERS_ERR);
767 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
768 proxy_->RegisterIAbilityManagerCollaborator(type, impl);
769 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RegisterIAbilityManagerCollaborator_0100 end");
770 }
771
772 /**
773 * @tc.name: AbilityManagerProxy_UnregisterIAbilityManagerCollaborator_0100
774 * @tc.desc: UnregisterIAbilityManagerCollaborator
775 * @tc.type: FUNC
776 */
777 HWTEST_F(AbilityManagerProxySecondTest, UnregisterIAbilityManagerCollaborator_0100, TestSize.Level1)
778 {
779 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UnregisterIAbilityManagerCollaborator_0100 start");
780 int32_t type = 0;
781 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
782 EXPECT_EQ(proxy_->UnregisterIAbilityManagerCollaborator(type), INVALID_PARAMETERS_ERR);
783 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
784 proxy_->UnregisterIAbilityManagerCollaborator(type);
785 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_UnregisterIAbilityManagerCollaborator_0100 end");
786 }
787
788 /**
789 * @tc.name: AbilityManagerProxy_GetAbilityManagerCollaborator_0100
790 * @tc.desc: GetAbilityManagerCollaborator
791 * @tc.type: FUNC
792 */
793 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_GetAbilityManagerCollaborator_0100, TestSize.Level1)
794 {
795 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetAbilityManagerCollaborator_0100 start");
796 EXPECT_EQ(proxy_->GetAbilityManagerCollaborator(), nullptr);
797 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_GetAbilityManagerCollaborator_0100 end");
798 }
799
800 /**
801 * @tc.name: AbilityManagerProxy_RegisterStatusBarDelegate_0100
802 * @tc.desc: RegisterStatusBarDelegate
803 * @tc.type: FUNC
804 */
805 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_RegisterStatusBarDelegate_0100, TestSize.Level1)
806 {
807 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RegisterStatusBarDelegate_0100 start");
808 EXPECT_EQ(proxy_->RegisterStatusBarDelegate(nullptr), ERR_NULL_OBJECT);
809 sptr<AbilityRuntime::IStatusBarDelegate> delegate = new MockIStatusBarDelegate();
810 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
811 EXPECT_EQ(proxy_->RegisterStatusBarDelegate(delegate), INVALID_PARAMETERS_ERR);
812 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
813 proxy_->RegisterStatusBarDelegate(delegate);
814 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_RegisterStatusBarDelegate_0100 end");
815 }
816
817 /**
818 * @tc.name: AbilityManagerProxy_KillProcessWithPrepareTerminate_0100
819 * @tc.desc: KillProcessWithPrepareTerminate
820 * @tc.type: FUNC
821 */
822 HWTEST_F(AbilityManagerProxySecondTest, AbilityManagerProxy_KillProcessWithPrepareTerminate_0100, TestSize.Level1)
823 {
824 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_KillProcessWithPrepareTerminate_0100 start");
825 std::vector<int32_t> pids;
826 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR));
827 EXPECT_EQ(proxy_->KillProcessWithPrepareTerminate(pids), INVALID_PARAMETERS_ERR);
828 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
829 EXPECT_EQ(proxy_->KillProcessWithPrepareTerminate(pids), NO_ERROR);
830 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_KillProcessWithPrepareTerminate_0100 end");
831 }
832 } // namespace AAFwk
833 } // namespace OHOS
834