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 #define private public
19 #include "mission_manager_client.h"
20 #undef private
21 #include "ability_manager_errors.h"
22 #include "ability_connect_callback_stub.h"
23 #include "ability_manager_client.h"
24 #include "appexecfwk_errors.h"
25 #include "scene_board_judgement.h"
26 #include "mission_snapshot.h"
27 #include "mission_info.h"
28 #include "ability_connect_callback_stub.h"
29
30 using namespace testing::ext;
31 using namespace OHOS::AppExecFwk;
32
33 const std::string BUNDLE_NAME = "bundleName";
34
35 namespace OHOS {
36 namespace AAFwk {
37
38 class MissionManagerClientTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44
45 std::shared_ptr<MissionManagerClient> client_{ nullptr };
46 };
47
48 class AbilityConnectCallback : public AbilityConnectionStub {
49 public:
AbilityConnectCallback()50 AbilityConnectCallback() {};
~AbilityConnectCallback()51 virtual ~AbilityConnectCallback() {};
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)52 virtual void OnAbilityConnectDone(
53 const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) override
54 {}
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)55 virtual void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override
56 {}
57 static int onAbilityConnectDoneCount;
58 static int onAbilityDisconnectDoneCount;
59 };
60
61 class MockIRemoteMissionListener : public IRemoteMissionListener {
62 public:
MockIRemoteMissionListener()63 MockIRemoteMissionListener() {};
~MockIRemoteMissionListener()64 virtual ~MockIRemoteMissionListener() {};
NotifyMissionsChanged(const std::string & deviceId)65 void NotifyMissionsChanged(const std::string& deviceId) override
66 {}
67
NotifySnapshot(const std::string & deviceId,int32_t missionId)68 void NotifySnapshot(const std::string& deviceId, int32_t missionId) override
69 {}
70
NotifyNetDisconnect(const std::string & deviceId,int32_t state)71 void NotifyNetDisconnect(const std::string& deviceId, int32_t state) override
72 {}
AsObject()73 sptr<IRemoteObject> AsObject() override
74 { return nullptr; }
75 };
76
SetUpTestCase(void)77 void MissionManagerClientTest::SetUpTestCase(void)
78 {}
TearDownTestCase(void)79 void MissionManagerClientTest::TearDownTestCase(void)
80 {}
SetUp(void)81 void MissionManagerClientTest::SetUp(void)
82 {
83 client_ = std::make_shared<MissionManagerClient>();
84 }
TearDown(void)85 void MissionManagerClientTest::TearDown(void)
86 {}
87
88 /**
89 * @tc.name: MissionManagerClient_ContinueMission_0100
90 * @tc.desc: ContinueMission
91 * @tc.type: FUNC
92 */
93 HWTEST_F(MissionManagerClientTest, ContinueMission_0100, TestSize.Level1)
94 {
95 GTEST_LOG_(INFO) << "ContinueMission_0100 start";
96 std::string srcDeviceId = "123";
97 std::string dstDeviceId = "ABC";
98 int32_t missionId = 5;
99 sptr<IRemoteObject> callback = nullptr;
100 WantParams wantParams;
101 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
102
103 EXPECT_EQ(result, ERR_INVALID_VALUE);
104 GTEST_LOG_(INFO) << "ContinueMission_0100 end";
105 }
106
107 /**
108 * @tc.name: MissionManagerClient_ContinueMission_0200
109 * @tc.desc: ContinueMission
110 * @tc.type: FUNC
111 */
112 HWTEST_F(MissionManagerClientTest, ContinueMission_0200, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO) << "ContinueMission_0200 start";
115 std::string srcDeviceId = "";
116 std::string dstDeviceId = "ABC";
117 int32_t missionId = 5;
118 sptr<IRemoteObject> callback = nullptr;
119 WantParams wantParams;
120 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
121
122 EXPECT_EQ(result, ERR_INVALID_VALUE);
123 GTEST_LOG_(INFO) << "ContinueMission_0200 end";
124 }
125
126 /**
127 * @tc.name: MissionManagerClient_ContinueMission_0300
128 * @tc.desc: ContinueMission
129 * @tc.type: FUNC
130 */
131 HWTEST_F(MissionManagerClientTest, ContinueMission_0300, TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "ContinueMission_0300 start";
134 std::string srcDeviceId = "123";
135 std::string dstDeviceId = "";
136 int32_t missionId = 5;
137 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
138 WantParams wantParams;
139 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
140
141 EXPECT_EQ(result, ERR_INVALID_VALUE);
142 GTEST_LOG_(INFO) << "ContinueMission_0300 end";
143 }
144
145 /**
146 * @tc.name: MissionManagerClient_ContinueMission_0400
147 * @tc.desc: ContinueMission
148 * @tc.type: FUNC
149 */
150 HWTEST_F(MissionManagerClientTest, ContinueMission_0400, TestSize.Level1)
151 {
152 GTEST_LOG_(INFO) << "ContinueMission_0400 start";
153 std::string srcDeviceId = "";
154 std::string dstDeviceId = "ABC";
155 int32_t missionId = 5;
156 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
157 WantParams wantParams;
158 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
159
160 EXPECT_EQ(result, ERR_INVALID_VALUE);
161 GTEST_LOG_(INFO) << "ContinueMission_0400 end";
162 }
163
164 /**
165 * @tc.name: MissionManagerClient_ContinueMission_0500
166 * @tc.desc: ContinueMission
167 * @tc.type: FUNC
168 */
169 HWTEST_F(MissionManagerClientTest, ContinueMission_0500, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "ContinueMission_0500 start";
172 std::string srcDeviceId = "";
173 std::string dstDeviceId = "";
174 int32_t missionId = 5;
175 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
176 WantParams wantParams;
177 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
178
179 EXPECT_EQ(result, ERR_INVALID_VALUE);
180 GTEST_LOG_(INFO) << "ContinueMission_0500 end";
181 }
182
183 /**
184 * @tc.name: MissionManagerClient_ContinueMission_0600
185 * @tc.desc: ContinueMission
186 * @tc.type: FUNC
187 */
188 HWTEST_F(MissionManagerClientTest, ContinueMission_0600, TestSize.Level1)
189 {
190 GTEST_LOG_(INFO) << "ContinueMission_0600 start";
191 std::string srcDeviceId = "123";
192 std::string dstDeviceId = "";
193 int32_t missionId = 5;
194 sptr<IRemoteObject> callback = nullptr;
195 WantParams wantParams;
196 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
197
198 EXPECT_EQ(result, ERR_INVALID_VALUE);
199 GTEST_LOG_(INFO) << "ContinueMission_0600 end";
200 }
201
202 /**
203 * @tc.name: MissionManagerClient_ContinueMission_0700
204 * @tc.desc: ContinueMission
205 * @tc.type: FUNC
206 */
207 HWTEST_F(MissionManagerClientTest, ContinueMission_0700, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "ContinueMission_0700 start";
210 std::string srcDeviceId = "123";
211 std::string dstDeviceId = "ABC";
212 int32_t missionId = 5;
213 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
214 WantParams wantParams;
215 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
216
217 EXPECT_EQ(result, ERR_INVALID_STATE);
218 GTEST_LOG_(INFO) << "ContinueMission_0700 end";
219 }
220
221 /**
222 * @tc.name: MissionManagerClient_ContinueMission_0800
223 * @tc.desc: ContinueMission
224 * @tc.type: FUNC
225 */
226 HWTEST_F(MissionManagerClientTest, ContinueMission_0800, TestSize.Level1)
227 {
228 GTEST_LOG_(INFO) << "ContinueMission_0800 start";
229 AAFwk::ContinueMissionInfo continueMissionInfo;
230 continueMissionInfo.srcDeviceId = "123";
231 continueMissionInfo.dstDeviceId = "ABC";
232 sptr<IRemoteObject> callback = nullptr;
233 auto result = client_->ContinueMission(continueMissionInfo, callback);
234
235 EXPECT_EQ(result, ERR_INVALID_VALUE);
236 GTEST_LOG_(INFO) << "ContinueMission_0800 end";
237 }
238
239 /**
240 * @tc.name: MissionManagerClient_ContinueMission_0900
241 * @tc.desc: ContinueMission
242 * @tc.type: FUNC
243 */
244 HWTEST_F(MissionManagerClientTest, ContinueMission_0900, TestSize.Level1)
245 {
246 GTEST_LOG_(INFO) << "ContinueMission_0900 start";
247 AAFwk::ContinueMissionInfo continueMissionInfo;
248 continueMissionInfo.srcDeviceId = "";
249 continueMissionInfo.dstDeviceId = "ABC";
250 sptr<IRemoteObject> callback = nullptr;
251 auto result = client_->ContinueMission(continueMissionInfo, callback);
252
253 EXPECT_EQ(result, ERR_INVALID_VALUE);
254 GTEST_LOG_(INFO) << "ContinueMission_0900 end";
255 }
256
257 /**
258 * @tc.name: MissionManagerClient_ContinueMission_1000
259 * @tc.desc: ContinueMission
260 * @tc.type: FUNC
261 */
262 HWTEST_F(MissionManagerClientTest, ContinueMission_1000, TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "ContinueMission_1000 start";
265 AAFwk::ContinueMissionInfo continueMissionInfo;
266 continueMissionInfo.srcDeviceId = "123";
267 continueMissionInfo.dstDeviceId = "";
268 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
269 auto result = client_->ContinueMission(continueMissionInfo, callback);
270
271 EXPECT_EQ(result, ERR_INVALID_VALUE);
272 GTEST_LOG_(INFO) << "ContinueMission_1000 end";
273 }
274
275 /**
276 * @tc.name: MissionManagerClient_ContinueMission_1100
277 * @tc.desc: ContinueMission
278 * @tc.type: FUNC
279 */
280 HWTEST_F(MissionManagerClientTest, ContinueMission_1100, TestSize.Level1)
281 {
282 GTEST_LOG_(INFO) << "ContinueMission_1100 start";
283 AAFwk::ContinueMissionInfo continueMissionInfo;
284 continueMissionInfo.srcDeviceId = "";
285 continueMissionInfo.dstDeviceId = "ABC";
286 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
287 auto result = client_->ContinueMission(continueMissionInfo, callback);
288
289 EXPECT_EQ(result, ERR_INVALID_VALUE);
290 GTEST_LOG_(INFO) << "ContinueMission_1100 end";
291 }
292
293 /**
294 * @tc.name: MissionManagerClient_ContinueMission_1200
295 * @tc.desc: ContinueMission
296 * @tc.type: FUNC
297 */
298 HWTEST_F(MissionManagerClientTest, ContinueMission_1200, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "ContinueMission_1200 start";
301 AAFwk::ContinueMissionInfo continueMissionInfo;
302 continueMissionInfo.srcDeviceId = "";
303 continueMissionInfo.dstDeviceId = "";
304 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
305 auto result = client_->ContinueMission(continueMissionInfo, callback);
306
307 EXPECT_EQ(result, ERR_INVALID_VALUE);
308 GTEST_LOG_(INFO) << "ContinueMission_1200 end";
309 }
310
311 /**
312 * @tc.name: MissionManagerClient_ContinueMission_1300
313 * @tc.desc: ContinueMission
314 * @tc.type: FUNC
315 */
316 HWTEST_F(MissionManagerClientTest, ContinueMission_1300, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "ContinueMission_1300 start";
319 AAFwk::ContinueMissionInfo continueMissionInfo;
320 continueMissionInfo.srcDeviceId = "123";
321 continueMissionInfo.dstDeviceId = "";
322 sptr<IRemoteObject> callback = nullptr;
323 auto result = client_->ContinueMission(continueMissionInfo, callback);
324
325 EXPECT_EQ(result, ERR_INVALID_VALUE);
326 GTEST_LOG_(INFO) << "ContinueMission_1300 end";
327 }
328
329 /**
330 * @tc.name: MissionManagerClient_ContinueMission_1400
331 * @tc.desc: ContinueMission
332 * @tc.type: FUNC
333 */
334 HWTEST_F(MissionManagerClientTest, ContinueMission_1400, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "ContinueMission_1400 start";
337 AAFwk::ContinueMissionInfo continueMissionInfo;
338 continueMissionInfo.srcDeviceId = "123";
339 continueMissionInfo.dstDeviceId = "ABC";
340 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
341 auto result = client_->ContinueMission(continueMissionInfo, callback);
342
343 EXPECT_EQ(result, ERR_INVALID_STATE);
344 GTEST_LOG_(INFO) << "ContinueMission_1400 end";
345 }
346
347 /**
348 * @tc.name: MissionManagerClient_LockMissionForCleanup_0100
349 * @tc.desc: LockMissionForCleanup
350 * @tc.type: FUNC
351 * @tc.require: issueI5NRWT
352 */
353 HWTEST_F(MissionManagerClientTest, LockMissionForCleanup_0100, TestSize.Level1)
354 {
355 EXPECT_TRUE(client_ != nullptr);
356 auto result = client_->LockMissionForCleanup(1);
357 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
358 EXPECT_EQ(ERR_INVALID_STATE, result);
359 }
360 }
361
362 /**
363 * @tc.name: MissionManagerClient_LockMissionForCleanup_0200
364 * @tc.desc: LockMissionForCleanup
365 * @tc.type: FUNC
366 * @tc.require: issueI5NRWT
367 */
368 HWTEST_F(MissionManagerClientTest, LockMissionForCleanup_0200, TestSize.Level1)
369 {
370 EXPECT_TRUE(client_ != nullptr);
371 auto result = client_->LockMissionForCleanup(1);
372 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
373 EXPECT_EQ(result, ERR_INVALID_STATE);
374 }
375 }
376
377 /**
378 * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0100
379 * @tc.desc: UnlockMissionForCleanup
380 * @tc.type: FUNC
381 * @tc.require: issue
382 */
383 HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0100, TestSize.Level1)
384 {
385 EXPECT_TRUE(client_ != nullptr);
386 auto result = client_->UnlockMissionForCleanup(5);
387 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
388 EXPECT_EQ(result, ERR_INVALID_STATE);
389 }
390 }
391
392 /**
393 * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0200
394 * @tc.desc: UnlockMissionForCleanup
395 * @tc.type: FUNC
396 * @tc.require: issue
397 */
398 HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0200, TestSize.Level1)
399 {
400 EXPECT_TRUE(client_ != nullptr);
401 auto result = client_->UnlockMissionForCleanup(5);
402 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
403 EXPECT_EQ(result, ERR_INVALID_STATE);
404 }
405 }
406
407
408 /**
409 * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0300
410 * @tc.desc: UnlockMissionForCleanup
411 * @tc.type: FUNC
412 * @tc.require: issue
413 */
414 HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0300, TestSize.Level1)
415 {
416 EXPECT_TRUE(client_ != nullptr);
417 auto result = client_->UnlockMissionForCleanup(5);
418 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
419 EXPECT_EQ(result, ERR_INVALID_STATE);
420 }
421 }
422
423 /**
424 * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0400
425 * @tc.desc: UnlockMissionForCleanup
426 * @tc.type: FUNC
427 * @tc.require: issue
428 */
429 HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0400, TestSize.Level1)
430 {
431 EXPECT_TRUE(client_ != nullptr);
432 auto result = client_->UnlockMissionForCleanup(5);
433 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
434 EXPECT_EQ(result, ERR_INVALID_STATE);
435 }
436 }
437
438 /**
439 * @tc.name: MissionManagerClient_RegisterMissionListener_0100
440 * @tc.desc: RegisterMissionListener
441 * @tc.type: FUNC
442 * @tc.require: issue
443 */
444 HWTEST_F(MissionManagerClientTest, RegisterMissionListener_0100, TestSize.Level1)
445 {
446 EXPECT_TRUE(client_ != nullptr);
447 sptr<IMissionListener> listener = nullptr;
448 auto result = client_->RegisterMissionListener(listener);
449 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
450 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
451 }
452 }
453
454 /**
455 * @tc.name: MissionManagerClient_UnRegisterMissionListener_0100
456 * @tc.desc: UnRegisterMissionListener
457 * @tc.type: FUNC
458 * @tc.require: issue
459 */
460 HWTEST_F(MissionManagerClientTest, UnRegisterMissionListener_0100, TestSize.Level1)
461 {
462 EXPECT_TRUE(client_ != nullptr);
463 sptr<IMissionListener> listener = nullptr;
464 auto result = client_->UnRegisterMissionListener(listener);
465 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
466 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
467 }
468 }
469
470 /**
471 * @tc.name: MissionManagerClient_RegisterMissionListener_0200
472 * @tc.desc: RegisterMissionListener
473 * @tc.type: FUNC
474 * @tc.require: issue
475 */
476 HWTEST_F(MissionManagerClientTest, RegisterMissionListener_0200, TestSize.Level1)
477 {
478 EXPECT_TRUE(client_ != nullptr);
479 std::string deviceId = "123";
480 sptr<MockIRemoteMissionListener> listener = new (std::nothrow) MockIRemoteMissionListener();
481 auto result = client_->RegisterMissionListener(deviceId, listener);
482 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
483 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
484 }
485 }
486
487 /**
488 * @tc.name: MissionManagerClient_UnRegisterMissionListener_0200
489 * @tc.desc: UnRegisterMissionListener
490 * @tc.type: FUNC
491 * @tc.require: issue
492 */
493 HWTEST_F(MissionManagerClientTest, UnRegisterMissionListener_0200, TestSize.Level1)
494 {
495 EXPECT_TRUE(client_ != nullptr);
496 std::string deviceId = "123";
497 sptr<MockIRemoteMissionListener> listener = new (std::nothrow) MockIRemoteMissionListener();
498 auto result = client_->UnRegisterMissionListener(deviceId, listener);
499 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
500 EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
501 }
502 }
503
504 /**
505 * @tc.name: MissionManagerClient_GetMissionInfos_0100
506 * @tc.desc: GetMissionInfos
507 * @tc.type: FUNC
508 * @tc.require: issue
509 */
510 HWTEST_F(MissionManagerClientTest, GetMissionInfos_0100, TestSize.Level1)
511 {
512 EXPECT_TRUE(client_ != nullptr);
513 std::string deviceId = "123";
514 std::vector<MissionInfo> missionInfos;
515 auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
516 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
517 EXPECT_EQ(result, ERR_INVALID_STATE);
518 }
519 }
520
521 /**
522 * @tc.name: MissionManagerClient_GetMissionInfo_0100
523 * @tc.desc: GetMissionInfo
524 * @tc.type: FUNC
525 */
526 HWTEST_F(MissionManagerClientTest, GetMissionInfo_0100, TestSize.Level1)
527 {
528 EXPECT_TRUE(client_ != nullptr);
529 std::string deviceId = "123";
530 int32_t missionId = 1;
531 MissionInfo missionInfo;
532 auto result = client_->GetMissionInfo(deviceId, missionId, missionInfo);
533 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
534 EXPECT_EQ(result, ERR_INVALID_STATE);
535 }
536 }
537
538
539 /**
540 * @tc.name: MissionManagerClient_GetMissionSnapshot_0100
541 * @tc.desc: GetMissionSnapshot
542 * @tc.type: FUNC
543 * @tc.require: issue
544 */
545 HWTEST_F(MissionManagerClientTest, GetMissionSnapshot_0100, TestSize.Level1)
546 {
547 EXPECT_TRUE(client_ != nullptr);
548 std::string deviceId = "123";
549 MissionSnapshot snapshot;
550 bool isLowResolution = false;
551 auto result = client_->GetMissionSnapshot(deviceId, 10, snapshot, isLowResolution);
552 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
553 EXPECT_EQ(result, ERR_INVALID_STATE);
554 }
555 }
556
557 /**
558 * @tc.name: MissionManagerClient_CleanMission_0100
559 * @tc.desc: CleanMission
560 * @tc.type: FUNC
561 * @tc.require: issue
562 */
563 HWTEST_F(MissionManagerClientTest, CleanMission_0100, TestSize.Level1)
564 {
565 EXPECT_TRUE(client_ != nullptr);
566 auto result = client_->CleanMission(10);
567 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
568 EXPECT_EQ(result, ERR_INVALID_STATE);
569 }
570 }
571
572 /**
573 * @tc.name: MissionManagerClient_CleanAllMissions_0100
574 * @tc.desc: CleanAllMissions
575 * @tc.type: FUNC
576 * @tc.require: issue
577 */
578 HWTEST_F(MissionManagerClientTest, CleanAllMissions_0100, TestSize.Level1)
579 {
580 EXPECT_TRUE(client_ != nullptr);
581 auto result = client_->CleanAllMissions();
582 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
583 EXPECT_EQ(result, ERR_INVALID_STATE);
584 }
585 }
586
587 /**
588 * @tc.name: MissionManagerClient_MoveMissionToFront_0100
589 * @tc.desc: MoveMissionToFront
590 * @tc.type: FUNC
591 * @tc.require: issue
592 */
593 HWTEST_F(MissionManagerClientTest, MoveMissionToFront_0100, TestSize.Level1)
594 {
595 auto result = client_->MoveMissionToFront(10);
596 EXPECT_EQ(result, ERR_INVALID_STATE);
597 }
598
599 /**
600 * @tc.name: MissionManagerClient_MoveMissionToFront_0200
601 * @tc.desc: MoveMissionToFront
602 * @tc.type: FUNC
603 * @tc.require: issue
604 */
605 HWTEST_F(MissionManagerClientTest, MoveMissionToFront_0200, TestSize.Level1)
606 {
607 StartOptions startOptions;
608 auto result = client_->MoveMissionToFront(1, startOptions);
609 EXPECT_EQ(result, ERR_INVALID_STATE);
610 }
611
612 /**
613 * @tc.name: MissionManagerClient_MoveMissionsToForeground_0100
614 * @tc.desc: MoveMissionsToForeground
615 * @tc.type: FUNC
616 * @tc.require: issue
617 */
618 HWTEST_F(MissionManagerClientTest, MoveMissionsToForeground_0100, TestSize.Level1)
619 {
620 EXPECT_TRUE(client_ != nullptr);
621 auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1);
622 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
623 EXPECT_EQ(result, ERR_INVALID_STATE);
624 }
625 }
626
627 /**
628 * @tc.name: MissionManagerClient_MoveMissionsToForeground_0200
629 * @tc.desc: MoveMissionsToForeground
630 * @tc.type: FUNC
631 * @tc.require: issue
632 */
633 HWTEST_F(MissionManagerClientTest, MoveMissionsToForeground_0200, TestSize.Level1)
634 {
635 EXPECT_TRUE(client_ != nullptr);
636 auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1);
637 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
638 EXPECT_EQ(result, ERR_INVALID_STATE);
639 }
640 }
641
642 /**
643 * @tc.name: MissionManagerClient_MoveMissionsToBackground_0100
644 * @tc.desc: MoveMissionsToBackground
645 * @tc.type: FUNC
646 * @tc.require: issue
647 */
648 HWTEST_F(MissionManagerClientTest, MoveMissionsToBackground_0100, TestSize.Level1)
649 {
650 EXPECT_TRUE(client_ != nullptr);
651 std::vector<int32_t> result;
652 auto ret = client_->MoveMissionsToBackground({1, 2, 3}, result);
653 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
654 EXPECT_EQ(ret, ERR_INVALID_STATE);
655 }
656 }
657
658 /**
659 * @tc.name: MissionManagerClient_MoveMissionsToBackground_0200
660 * @tc.desc: MoveMissionsToBackground
661 * @tc.type: FUNC
662 * @tc.require: issue
663 */
664 HWTEST_F(MissionManagerClientTest, MoveMissionsToBackground_0200, TestSize.Level1)
665 {
666 EXPECT_TRUE(client_ != nullptr);
667 std::vector<int32_t> result;
668 auto ret = client_->MoveMissionsToBackground({1, 2, 3}, result);
669 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
670 EXPECT_EQ(ret, ERR_INVALID_STATE);
671 }
672 }
673
674 /**
675 * @tc.name: MissionManagerClient_GetMissionIdByToken_0100
676 * @tc.desc: GetMissionIdByToken
677 * @tc.type: FUNC
678 */
679 HWTEST_F(MissionManagerClientTest, GetMissionIdByToken_0100, TestSize.Level1)
680 {
681 GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 start";
682 sptr<IRemoteObject> token = nullptr;
683 int32_t missionId = 1;
684 auto result = client_->GetMissionIdByToken(token, missionId);
685
686 EXPECT_EQ(result, ERR_OK);
687 GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 end";
688 }
689
690 /**
691 * @tc.name: MissionManagerClient_StartSyncRemoteMissions_0100
692 * @tc.desc: StartSyncRemoteMissions
693 * @tc.type: FUNC
694 */
695 HWTEST_F(MissionManagerClientTest, StartSyncRemoteMissions_0100, TestSize.Level1)
696 {
697 GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 start";
698 std::string devId = BUNDLE_NAME;
699 bool fixConflict = true;
700 int64_t tag = 1;
701 auto result = client_->StartSyncRemoteMissions(devId, fixConflict, tag);
702
703 EXPECT_EQ(result, ERR_INVALID_STATE);
704 GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 end";
705 }
706
707 /**
708 * @tc.name: MissionManagerClient_StopSyncRemoteMissions_0100
709 * @tc.desc: StopSyncRemoteMissions
710 * @tc.type: FUNC
711 */
712 HWTEST_F(MissionManagerClientTest, StopSyncRemoteMissions_0100, TestSize.Level1)
713 {
714 GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 start";
715 std::string devId = BUNDLE_NAME;
716 auto result = client_->StopSyncRemoteMissions(devId);
717
718 EXPECT_EQ(result, ERR_INVALID_STATE);
719 GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 end";
720 }
721
722
723 /**
724 * @tc.name: MissionManagerClient_SetMissionContinueState_0100
725 * @tc.desc: SetMissionContinueState
726 * @tc.type: FUNC
727 */
728 HWTEST_F(MissionManagerClientTest, SetMissionContinueState_0100, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO) << "SetMissionContinueState_0100 start";
731 EXPECT_NE(client_, nullptr);
732 sptr<IRemoteObject> token = nullptr;
733 sptr<IRemoteObject> sessionToken = nullptr;
734 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_ACTIVE;
735 auto result = client_->SetMissionContinueState(token, state, sessionToken);
736 EXPECT_EQ(INVALID_PARAMETERS_ERR, result);
737 GTEST_LOG_(INFO) << "SetMissionContinueState_0100 end";
738 }
739
740 /**
741 * @tc.name: MissionManagerClient_SetMissionContinueState_0200
742 * @tc.desc: SetMissionContinueState
743 * @tc.type: FUNC
744 */
745 HWTEST_F(MissionManagerClientTest, SetMissionContinueState_0200, TestSize.Level1)
746 {
747 GTEST_LOG_(INFO) << "SetMissionContinueState_0200 start";
748 EXPECT_NE(client_, nullptr);
749 sptr<IRemoteObject> token = nullptr;
750 sptr<IRemoteObject> sessionToken = nullptr;
751 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_INACTIVE;
752 auto result = client_->SetMissionContinueState(token, state, sessionToken);
753 EXPECT_EQ(INVALID_PARAMETERS_ERR, result);
754 GTEST_LOG_(INFO) << "SetMissionContinueState_0200 end";
755 }
756
757 #ifdef SUPPORT_SCREEN
758 /**
759 * @tc.name: MissionManagerClient_SetMissionLabel_0100
760 * @tc.desc: SetMissionLabel
761 * @tc.type: FUNC
762 */
763 HWTEST_F(MissionManagerClientTest, MissionManagerClient_SetMissionLabel_0100, TestSize.Level1)
764 {
765 GTEST_LOG_(INFO) << "MissionManagerClient_SetMissionLabel_0100 start";
766 sptr<IRemoteObject> token = nullptr;
767 std::string label = "label";
768 ErrCode ret = client_->SetMissionLabel(token, label);
769 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
770 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
771 }
772 EXPECT_TRUE(client_ != nullptr);
773 GTEST_LOG_(INFO) << "MissionManagerClient_SetMissionLabel_0100 end";
774 }
775
776 /**
777 * @tc.name: MissionManagerClient_SetMissionIcon_0100
778 * @tc.desc: SetMissionIcon
779 * @tc.type: FUNC
780 * @tc.require: SR000GVIJQ
781 */
782 HWTEST_F(MissionManagerClientTest, MissionManagerClient_SetMissionIcon_0100, TestSize.Level1)
783 {
784 sptr<IRemoteObject> abilityToken = nullptr;
785 std::shared_ptr<OHOS::Media::PixelMap> icon = nullptr;
786
787 auto result = client_->SetMissionIcon(abilityToken, icon);
788 EXPECT_NE(result, ERR_OK);
789 }
790
791 /**
792 * @tc.number: UpdateMissionSnapShot_0100
793 * @tc.name: UpdateMissionSnapShot
794 * @tc.desc: The caller is expected to be dlp manager.
795 */
796 HWTEST_F(MissionManagerClientTest, UpdateMissionSnapShot_0100, TestSize.Level1)
797 {
798 sptr<IRemoteObject> token = nullptr;
799 auto pixelMap = std::shared_ptr<Media::PixelMap>();
800 client_->UpdateMissionSnapShot(token, pixelMap);
801 EXPECT_TRUE(client_ != nullptr);
802 }
803 #endif
804
805 /**
806 * @tc.name: MissionManagerClient_IsValidMissionIds_0100
807 * @tc.desc: IsValidMissionIds
808 * @tc.type: FUNC
809 * @tc.require: issue
810 */
811 HWTEST_F(MissionManagerClientTest, IsValidMissionIds_0100, TestSize.Level1)
812 {
813 EXPECT_TRUE(client_ != nullptr);
814 std::vector<MissionValidResult> results;
815 auto result = client_->IsValidMissionIds({1, 2, 3}, results);
816 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
817 EXPECT_EQ(result, ERR_INVALID_STATE);
818 }
819 }
820
821 /**
822 * @tc.name: MissionManagerClient_PreStartMission_0100
823 * @tc.desc: CallRequestDone
824 * @tc.type: FUNC
825 */
826 HWTEST_F(MissionManagerClientTest, PreStartMission_0100, TestSize.Level1)
827 {
828 GTEST_LOG_(INFO) << "PreStartMission_0100 start";
829 EXPECT_TRUE(client_ != nullptr);
830 std::string bundleName = "bundleName";
831 std::string moduleName = "moduleName";
832 std::string abilityName = "abilityName";
833 std::string startTime = "startTime";
834 ErrCode result = client_->PreStartMission(bundleName, moduleName, abilityName, startTime);
835 EXPECT_EQ(result, ERR_INVALID_STATE);
836 GTEST_LOG_(INFO) << "PreStartMission_0100 end";
837 }
838
839 /**
840 * @tc.name: MissionManagerClient_TerminateMission_0100
841 * @tc.desc: TerminateMission
842 * @tc.type: FUNC
843 */
844 HWTEST_F(MissionManagerClientTest, MissionManagerClient_TerminateMission_0100, TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "MissionManagerClient_TerminateMission_0100 start";
847 int32_t missionId = 1;
848 ErrCode result = client_->TerminateMission(missionId);
849 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
850 EXPECT_EQ(result, ERR_INVALID_STATE);
851 }
852 EXPECT_NE(client_, nullptr);
853 GTEST_LOG_(INFO) << "MissionManagerClient_TerminateMission_0100 end";
854 }
855
856 /**
857 * @tc.name: MissionManagerClient_Release_0100
858 * @tc.desc: Release
859 * @tc.type: FUNC
860 */
861 HWTEST_F(MissionManagerClientTest, MissionManagerClient_Release_0100, TestSize.Level1)
862 {
863 GTEST_LOG_(INFO) << "MissionManagerClient_Release_0100 start";
864 auto &client = MissionManagerClient::GetInstance();
865 auto ret = client.Release();
866 EXPECT_EQ(ret, ERR_NULL_OBJECT);
867 GTEST_LOG_(INFO) << "MissionManagerClient_Release_0100 end";
868 }
869 }
870 }