1 /*
2 * Copyright (c) 2024-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <fstream>
17 #include "gtest/gtest.h"
18 #include "iservice_registry.h"
19 #include "string_ex.h"
20 #include "test_log.h"
21 #include "hisysevent_adapter.h"
22
23 #define private public
24 #include "local_ability_manager.h"
25 #include "mock_sa_realize.h"
26 #undef private
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace SAFWK {
32 namespace {
33 const std::string TEST_RESOURCE_PATH = "/data/test/resource/safwk/profile/";
34 const std::u16string LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN = u"ohos.localabilitymanager.accessToken";
35 constexpr int SAID = 1499;
36 constexpr int MUT_SAID = 9999;
37 constexpr int INVALID_SAID = -1;
38 constexpr int STARTCODE = 1;
39 constexpr const char* EVENT_ID = "eventId";
40 constexpr const char* NAME = "name";
41 constexpr const char* VALUE = "value";
42 constexpr const char* EXTRA_DATA_ID = "extraDataId";
43 }
44
45 class LocalAbilityManagerStubTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase()53 void LocalAbilityManagerStubTest::SetUpTestCase()
54 {
55 DTEST_LOG << "SetUpTestCase" << std::endl;
56 }
57
TearDownTestCase()58 void LocalAbilityManagerStubTest::TearDownTestCase()
59 {
60 DTEST_LOG << "TearDownTestCase" << std::endl;
61 }
62
SetUp()63 void LocalAbilityManagerStubTest::SetUp()
64 {
65 DTEST_LOG << "SetUp" << std::endl;
66 }
67
TearDown()68 void LocalAbilityManagerStubTest::TearDown()
69 {
70 DTEST_LOG << "TearDown" << std::endl;
71 }
72
73 /**
74 * @tc.name: OnRemoteRequest001
75 * @tc.desc: OnRemoteRequest001
76 * @tc.type: FUNC
77 */
78 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest001, TestSize.Level2)
79 {
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option;
83 std::string deviceId = "";
84 LocalAbilityManager::SystemAbilityListener *sysListener =
85 new LocalAbilityManager::SystemAbilityListener(SAID);
86 sysListener->OnAddSystemAbility(SAID, deviceId);
87 int32_t result = LocalAbilityManager::GetInstance().OnRemoteRequest(0, data, reply, option);
88 delete sysListener;
89 EXPECT_NE(result, ERR_NONE);
90 }
91
92 /**
93 * @tc.name: OnRemoteRequest002
94 * @tc.desc: OnRemoteRequest002
95 * @tc.type: FUNC
96 */
97 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest002, TestSize.Level2)
98 {
99 MessageParcel data;
100 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
101 MessageParcel reply;
102 MessageOption option;
103 std::string deviceId = "";
104 LocalAbilityManager::SystemAbilityListener *sysListener =
105 new LocalAbilityManager::SystemAbilityListener(INVALID_SAID);
106 sysListener->OnAddSystemAbility(INVALID_SAID, deviceId);
107 int32_t result = LocalAbilityManager::GetInstance().OnRemoteRequest(0, data, reply, option);
108 delete sysListener;
109 EXPECT_NE(result, ERR_NONE);
110 }
111
112 /**
113 * @tc.name: OnRemoteRequest003
114 * @tc.desc: OnRemoteRequest003
115 * @tc.type: FUNC
116 */
117 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest003, TestSize.Level2)
118 {
119 MessageParcel data;
120 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
121 MessageParcel reply;
122 MessageOption option;
123 std::string deviceId = "";
124 LocalAbilityManager::SystemAbilityListener *sysListener =
125 new LocalAbilityManager::SystemAbilityListener(INVALID_SAID);
126 sysListener->OnRemoveSystemAbility(INVALID_SAID, deviceId);
127 int32_t result = LocalAbilityManager::GetInstance().OnRemoteRequest(STARTCODE, data, reply, option);
128 delete sysListener;
129 EXPECT_NE(result, ERR_NONE);
130 }
131
132 /**
133 * @tc.name: OnRemoteRequest004
134 * @tc.desc: OnRemoteRequest004
135 * @tc.type: FUNC
136 */
137 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest004, TestSize.Level2)
138 {
139 MessageParcel data;
140 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
141 data.WriteInt32(STARTCODE);
142 MessageParcel reply;
143 MessageOption option;
144 std::string deviceId = "";
145 LocalAbilityManager::SystemAbilityListener *sysListener =
146 new LocalAbilityManager::SystemAbilityListener(SAID);
147 sysListener->OnRemoveSystemAbility(SAID, deviceId);
148 int32_t result = LocalAbilityManager::GetInstance().OnRemoteRequest(STARTCODE, data, reply, option);
149 delete sysListener;
150 EXPECT_EQ(result, ERR_NULL_OBJECT);
151 }
152
153 /**
154 * @tc.name: OnRemoteRequest005
155 * @tc.desc: OnRemoteRequest005
156 * @tc.type: FUNC
157 */
158 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest005, TestSize.Level2)
159 {
160 MessageParcel data;
161 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
162 data.WriteInt32(STARTCODE);
163 std::string eventStr = "test";
164 data.WriteString(eventStr);
165 MessageParcel reply;
166 MessageOption option;
167 std::string deviceId = "";
168 LocalAbilityManager::SystemAbilityListener *sysListener =
169 new LocalAbilityManager::SystemAbilityListener(SAID);
170 sysListener->OnRemoveSystemAbility(SAID, deviceId);
171 int32_t result = LocalAbilityManager::GetInstance().OnRemoteRequest(STARTCODE, data, reply, option);
172 delete sysListener;
173 EXPECT_EQ(result, ERR_NONE);
174 }
175
176 /**
177 * @tc.name: OnRemoteRequest006
178 * @tc.desc: OnRemoteRequest006
179 * @tc.type: FUNC
180 */
181 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest006, TestSize.Level2)
182 {
183 MessageParcel data;
184 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
185 data.WriteInt32(STARTCODE);
186 std::string eventStr = "test";
187 data.WriteString(eventStr);
188 MessageParcel reply;
189 MessageOption option;
190 uint32_t code = 1;
191 auto iter = LocalAbilityManager::GetInstance().memberFuncMap_.find(code);
192 LocalAbilityManager::GetInstance().OnRemoteRequest(code, data, reply, option);
193 EXPECT_NE(iter, LocalAbilityManager::GetInstance().memberFuncMap_.end());
194 }
195
196 /**
197 * @tc.name: OnRemoteRequest007
198 * @tc.desc: OnRemoteRequest007
199 * @tc.type: FUNC
200 */
201 HWTEST_F(LocalAbilityManagerStubTest, OnRemoteRequest007, TestSize.Level2)
202 {
203 MessageParcel data;
204 data.WriteInterfaceToken(LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN);
205 data.WriteInt32(STARTCODE);
206 std::string eventStr = "test";
207 data.WriteString(eventStr);
208 MessageParcel reply;
209 MessageOption option;
210 uint32_t code = 0;
211 auto iter = LocalAbilityManager::GetInstance().memberFuncMap_.find(code);
212 LocalAbilityManager::GetInstance().OnRemoteRequest(code, data, reply, option);
213 EXPECT_EQ(iter, LocalAbilityManager::GetInstance().memberFuncMap_.end());
214 }
215
216 /**
217 * @tc.name: StartAbilityInner001
218 * @tc.desc: test StartAbilityInner with invalid SaID
219 * @tc.type: FUNC
220 * @tc.require:I6LSSX
221 */
222 HWTEST_F(LocalAbilityManagerStubTest, StartAbilityInner001, TestSize.Level2)
223 {
224 MessageParcel data;
225 data.WriteInt32(INVALID_SAID);
226 MessageParcel reply;
227 int32_t ret = LocalAbilityManager::GetInstance().StartAbilityInner(data, reply);
228 EXPECT_EQ(ret, ERR_NULL_OBJECT);
229 }
230
231 /**
232 * @tc.name: StartAbilityInner002
233 * @tc.desc: test StartAbilityInner with data.ReadString() is empty
234 * @tc.type: FUNC
235 * @tc.require:I6LSSX
236 */
237 HWTEST_F(LocalAbilityManagerStubTest, StartAbilityInner002, TestSize.Level2)
238 {
239 MessageParcel data;
240 data.WriteInt32(STARTCODE);
241 MessageParcel reply;
242 int32_t ret = LocalAbilityManager::GetInstance().StartAbilityInner(data, reply);
243 EXPECT_EQ(ret, ERR_NULL_OBJECT);
244 }
245
246 /**
247 * @tc.name: StartAbilityInner003
248 * @tc.desc: test StartAbilityInner with data.ReadString() is not empty
249 * @tc.type: FUNC
250 * @tc.require:I6LSSX
251 */
252 HWTEST_F(LocalAbilityManagerStubTest, StartAbilityInner003, TestSize.Level2)
253 {
254 MessageParcel data;
255 data.WriteInt32(STARTCODE);
256 std::string eventStr = "test";
257 data.WriteString(eventStr);
258 MessageParcel reply;
259 int32_t ret = LocalAbilityManager::GetInstance().StartAbilityInner(data, reply);
260 EXPECT_EQ(ret, ERR_NONE);
261 }
262
263 /**
264 * @tc.name: StopAbilityInner001
265 * @tc.desc: test StopAbilityInner with invalid SaID
266 * @tc.type: FUNC
267 * @tc.require:I6LSSX
268 */
269 HWTEST_F(LocalAbilityManagerStubTest, StopAbilityInner001, TestSize.Level2)
270 {
271 MessageParcel data;
272 data.WriteInt32(INVALID_SAID);
273 MessageParcel reply;
274 int32_t ret = LocalAbilityManager::GetInstance().StopAbilityInner(data, reply);
275 EXPECT_EQ(ret, ERR_NULL_OBJECT);
276 }
277
278 /**
279 * @tc.name: StopAbilityInner002
280 * @tc.desc: test StopAbilityInner with data.ReadString() is empty
281 * @tc.type: FUNC
282 * @tc.require:I6LSSX
283 */
284 HWTEST_F(LocalAbilityManagerStubTest, StopAbilityInner002, TestSize.Level2)
285 {
286 MessageParcel data;
287 data.WriteInt32(STARTCODE);
288 MessageParcel reply;
289 int32_t ret = LocalAbilityManager::GetInstance().StopAbilityInner(data, reply);
290 EXPECT_EQ(ret, ERR_NULL_OBJECT);
291 }
292
293 /**
294 * @tc.name: StopAbilityInner003
295 * @tc.desc: test StopAbilityInner with data.ReadString() is empty
296 * @tc.type: FUNC
297 * @tc.require:I6LSSX
298 */
299 HWTEST_F(LocalAbilityManagerStubTest, StopAbilityInner003, TestSize.Level2)
300 {
301 MessageParcel data;
302 data.WriteInt32(STARTCODE);
303 std::string eventStr = "test";
304 data.WriteString(eventStr);
305 MessageParcel reply;
306 int32_t ret = LocalAbilityManager::GetInstance().StopAbilityInner(data, reply);
307 EXPECT_EQ(ret, ERR_NONE);
308 }
309
310 /**
311 * @tc.name: ActiveAbilityInner001
312 * @tc.desc: test ActiveAbilityInner with invalid SaID
313 * @tc.type: FUNC
314 * @tc.require:I6LSSX
315 */
316 HWTEST_F(LocalAbilityManagerStubTest, ActiveAbilityInner001, TestSize.Level2)
317 {
318 MessageParcel data;
319 data.WriteInt32(INVALID_SAID);
320 MessageParcel reply;
321 int32_t ret = LocalAbilityManager::GetInstance().ActiveAbilityInner(data, reply);
322 EXPECT_EQ(ret, ERR_NULL_OBJECT);
323 }
324
325 /**
326 * @tc.name: ActiveAbilityInner002
327 * @tc.desc: test ActiveAbilityInner with valid SaID
328 * @tc.type: FUNC
329 * @tc.require:I6LSSX
330 */
331 HWTEST_F(LocalAbilityManagerStubTest, ActiveAbilityInner002, TestSize.Level2)
332 {
333 MessageParcel data;
334 data.WriteInt32(STARTCODE);
335 MessageParcel reply;
336 int32_t ret = LocalAbilityManager::GetInstance().ActiveAbilityInner(data, reply);
337 EXPECT_EQ(ret, ERR_NONE);
338 }
339
340 /**
341 * @tc.name: IdleAbilityInner001
342 * @tc.desc: test IdleAbilityInner with invalid SaID
343 * @tc.type: FUNC
344 * @tc.require:I6LSSX
345 */
346 HWTEST_F(LocalAbilityManagerStubTest, IdleAbilityInner001, TestSize.Level2)
347 {
348 MessageParcel data;
349 data.WriteInt32(INVALID_SAID);
350 MessageParcel reply;
351 int32_t ret = LocalAbilityManager::GetInstance().IdleAbilityInner(data, reply);
352 EXPECT_EQ(ret, ERR_NULL_OBJECT);
353 }
354
355 /**
356 * @tc.name: IdleAbilityInner002
357 * @tc.desc: test IdleAbilityInner with valid SaID
358 * @tc.type: FUNC
359 * @tc.require:I6LSSX
360 */
361 HWTEST_F(LocalAbilityManagerStubTest, IdleAbilityInner002, TestSize.Level2)
362 {
363 MessageParcel data;
364 data.WriteInt32(STARTCODE);
365 MessageParcel reply;
366 int32_t ret = LocalAbilityManager::GetInstance().IdleAbilityInner(data, reply);
367 EXPECT_EQ(ret, ERR_NONE);
368 }
369
370 /**
371 * @tc.name: OnStopAbility001
372 * @tc.desc: test OnStopAbility, cover function with valid SaID
373 * @tc.type: FUNC
374 * @tc.require: I73XRZ
375 */
376 HWTEST_F(LocalAbilityManagerStubTest, OnStopAbility001, TestSize.Level2)
377 {
378 int32_t systemAbilityId = 1;
379 bool ret = LocalAbilityManager::GetInstance().OnStopAbility(systemAbilityId);
380 EXPECT_FALSE(ret);
381 }
382
383 /**
384 * @tc.name: OnStopAbility002
385 * @tc.desc: test OnStopAbility with said is in abilityMap_
386 * @tc.type: FUNC
387 * @tc.require: I7G7DL
388 */
389 HWTEST_F(LocalAbilityManagerStubTest, OnStopAbility002, TestSize.Level2)
390 {
391 MockSaRealize *mockSa = new MockSaRealize(SAID, false);
392 mockSa->abilityState_ = SystemAbilityState::NOT_LOADED;
393 LocalAbilityManager::GetInstance().abilityMap_[SAID] = mockSa;
394 bool ret = LocalAbilityManager::GetInstance().OnStopAbility(SAID);
395 delete mockSa;
396 EXPECT_TRUE(ret);
397 }
398
399 /**
400 * @tc.name: ActiveAbility001
401 * @tc.desc: test ActiveAbility, cover function with valid SaID
402 * @tc.type: FUNC
403 * @tc.require: I73XRZ
404 */
405 HWTEST_F(LocalAbilityManagerStubTest, ActiveAbility001, TestSize.Level2)
406 {
407 int32_t systemAbilityId = 1;
408 nlohmann::json activeReason;
409 bool ret = LocalAbilityManager::GetInstance().ActiveAbility(systemAbilityId, activeReason);
410 // cover StartPhaseTasks
411 std::list<SystemAbility*> systemAbilityList;
412 LocalAbilityManager::GetInstance().StartPhaseTasks(systemAbilityList);
413 EXPECT_FALSE(ret);
414 }
415
416 /**
417 * @tc.name: ActiveAbility002
418 * @tc.desc: test ActiveAbility with sa is existed
419 * @tc.type: FUNC
420 * @tc.require: I7G7DL
421 */
422 HWTEST_F(LocalAbilityManagerStubTest, ActiveAbility002, TestSize.Level2)
423 {
424 nlohmann::json activeReason;
425 MockSaRealize *mockSa = new MockSaRealize(SAID, false);
426 LocalAbilityManager::GetInstance().abilityMap_[SAID] = mockSa;
427 mockSa->abilityState_ = SystemAbilityState::ACTIVE;
428 bool ret = LocalAbilityManager::GetInstance().ActiveAbility(SAID, activeReason);
429 delete mockSa;
430 EXPECT_TRUE(ret);
431 }
432
433 /**
434 * @tc.name: IdleAbility001
435 * @tc.desc: test IdleAbility, cover function
436 * @tc.type: FUNC
437 * @tc.require: I73XRZ
438 */
439 HWTEST_F(LocalAbilityManagerStubTest, IdleAbility001, TestSize.Level2)
440 {
441 int32_t systemAbilityId = 1;
442 nlohmann::json activeReason;
443 int32_t delayTime = 0;
444 bool ret = LocalAbilityManager::GetInstance().IdleAbility(systemAbilityId, activeReason, delayTime);
445 // cover WaitForTasks
446 LocalAbilityManager::GetInstance().WaitForTasks();
447 // cover FindAndStartPhaseTasks
448 LocalAbilityManager::GetInstance().FindAndStartPhaseTasks(systemAbilityId);
449 EXPECT_FALSE(ret);
450 }
451
452 /**
453 * @tc.name: IdleAbility002
454 * @tc.desc: test IdleAbility with sa is existed
455 * @tc.type: FUNC
456 * @tc.require: I7G7DL
457 */
458 HWTEST_F(LocalAbilityManagerStubTest, IdleAbility002, TestSize.Level2)
459 {
460 nlohmann::json idleReason;
461 MockSaRealize *mockSa = new MockSaRealize(SAID, false);
462 LocalAbilityManager::GetInstance().abilityMap_[SAID] = mockSa;
463 mockSa->abilityState_ = SystemAbilityState::IDLE;
464 int delayTime = 0;
465 bool ret = LocalAbilityManager::GetInstance().IdleAbility(SAID, idleReason, delayTime);
466 delete mockSa;
467 EXPECT_TRUE(ret);
468 }
469
470 /**
471 * @tc.name: JsonToOnDemandReason001
472 * @tc.desc: test JsonToOnDemandReason, with assignments
473 * @tc.type: FUNC
474 * @tc.require: I73XRZ
475 */
476 HWTEST_F(LocalAbilityManagerStubTest, JsonToOnDemandReason001, TestSize.Level2)
477 {
478 SystemAbilityOnDemandReason onDemandStartReason;
479 nlohmann::json reasonJson;
480 reasonJson[EVENT_ID] = 1;
481 reasonJson[NAME] = "test";
482 reasonJson[VALUE] = "test";
483 reasonJson[EXTRA_DATA_ID] = 1;
484 onDemandStartReason.SetId(reasonJson[EVENT_ID]);
485 onDemandStartReason.SetName(reasonJson[NAME]);
486 onDemandStartReason.SetValue(reasonJson[VALUE]);
487 onDemandStartReason.SetExtraDataId(reasonJson[EXTRA_DATA_ID]);
488 SystemAbilityOnDemandReason ret = LocalAbilityManager::GetInstance().JsonToOnDemandReason(reasonJson);
489 EXPECT_EQ(ret.extraDataId_, onDemandStartReason.extraDataId_);
490 }
491
492 /**
493 * @tc.name: FfrtDumperProc001
494 * @tc.desc: test FfrtDumperProc
495 * @tc.type: FUNC
496 * @tc.require: I7G7DL
497 */
498 HWTEST_F(LocalAbilityManagerStubTest, FfrtDumperProc001, TestSize.Level2)
499 {
500 std::string ffrtDumperInfo;
501 bool result = LocalAbilityManager::GetInstance().FfrtDumperProc(ffrtDumperInfo);
502 EXPECT_TRUE(result);
503 }
504
505 /**
506 * @tc.name: SendStrategyToSA001
507 * @tc.desc: test SendStrategyToSA001, cover function with valid SaID
508 * @tc.type: FUNC
509 */
510 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSA001, TestSize.Level2)
511 {
512 int32_t systemAbilityId = 1;
513 std::string action = "";
514 bool ret = LocalAbilityManager::GetInstance().SendStrategyToSA(1, systemAbilityId, 1, action);
515 EXPECT_FALSE(ret);
516 }
517
518 /**
519 * @tc.name: SendStrategyToSA002
520 * @tc.desc: test SendStrategyToSA with said is in abilityMap_
521 * @tc.type: FUNC
522 */
523 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSA002, TestSize.Level2)
524 {
525 MockSaRealize *mockSa = new MockSaRealize(SAID, false);
526 mockSa->abilityState_ = SystemAbilityState::NOT_LOADED;
527 LocalAbilityManager::GetInstance().abilityMap_[SAID] = mockSa;
528 std::string action = "";
529 bool ret = LocalAbilityManager::GetInstance().SendStrategyToSA(1, SAID, 1, action);
530 delete mockSa;
531 EXPECT_TRUE(ret);
532 }
533
534 /**
535 * @tc.name: IpcStatCmdProc001
536 * @tc.desc: test IpcStatCmdProc001, cover function with valid fd and valid cmd
537 * @tc.type: FUNC
538 */
539 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProc001, TestSize.Level2)
540 {
541 int32_t fd = 1;
542 int32_t cmd = 0;
543 bool ret = LocalAbilityManager::GetInstance().IpcStatCmdProc(fd, cmd);
544 EXPECT_TRUE(ret);
545 }
546
547 /**
548 * @tc.name: IpcStatCmdProc002
549 * @tc.desc: test IpcStatCmdProc002, cover function with valid fd and invalid cmd
550 * @tc.type: FUNC
551 */
552 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProc002, TestSize.Level2)
553 {
554 int32_t fd = 1;
555 int32_t cmd = -1;
556 bool ret = LocalAbilityManager::GetInstance().IpcStatCmdProc(fd, cmd);
557 EXPECT_FALSE(ret);
558 }
559
560 /**
561 * @tc.name: IpcStatCmdProc003
562 * @tc.desc: test IpcStatCmdProc003, cover function with invalid fd and valid cmd
563 * @tc.type: FUNC
564 */
565 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProc003, TestSize.Level2)
566 {
567 int32_t fd = -1;
568 int32_t cmd = 0;
569 bool ret = LocalAbilityManager::GetInstance().IpcStatCmdProc(fd, cmd);
570 EXPECT_FALSE(ret);
571 }
572
573 /**
574 * @tc.name: IpcStatCmdProc004
575 * @tc.desc: test IpcStatCmdProc004, cover function with invalid fd and invalid cmd
576 * @tc.type: FUNC
577 */
578 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProc004, TestSize.Level2)
579 {
580 int32_t fd = -1;
581 int32_t cmd = -1;
582 bool ret = LocalAbilityManager::GetInstance().IpcStatCmdProc(fd, cmd);
583 EXPECT_FALSE(ret);
584 }
585
586 /**
587 * @tc.name: CheckPermission001
588 * @tc.desc: test CheckPermission001
589 * @tc.type: FUNC
590 */
591 HWTEST_F(LocalAbilityManagerStubTest, CheckPermission001, TestSize.Level2)
592 {
593 uint32_t code = static_cast<uint32_t>(SafwkInterfaceCode::START_ABILITY_TRANSACTION);
594 bool result = LocalAbilityManager::GetInstance().CheckPermission(code);
595 EXPECT_TRUE(result);
596 }
597
598 /**
599 * @tc.name: CheckPermission002
600 * @tc.desc: test CheckPermission002
601 * @tc.type: FUNC
602 */
603 HWTEST_F(LocalAbilityManagerStubTest, CheckPermission002, TestSize.Level2)
604 {
605 uint32_t code = static_cast<uint32_t>(SafwkInterfaceCode::SYSTEM_ABILITY_EXT_TRANSACTION);
606 bool result = LocalAbilityManager::GetInstance().CheckPermission(code);
607 EXPECT_TRUE(result);
608 }
609
610 /**
611 * @tc.name: SystemAbilityExtProc001
612 * @tc.desc: test SystemAbilityExtProc001
613 * @tc.type: FUNC
614 */
615 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProc001, TestSize.Level2)
616 {
617 std::string extension = "ext1";
618 SystemAbilityExtensionPara callback;
619 bool isAsync = false;
620 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProc(extension, INVALID_SAID, &callback, isAsync);
621 EXPECT_FALSE(ret == ERR_NONE);
622 }
623
624 /**
625 * @tc.name: SystemAbilityExtProc002
626 * @tc.desc: test SystemAbilityExtProc002
627 * @tc.type: FUNC
628 */
629 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProc002, TestSize.Level2)
630 {
631 std::string extension = "ext1";
632 SystemAbilityExtensionPara callback;
633 bool isAsync = false;
634
635 std::string deviceId = "";
636 MockSaRealize *sysAby = new MockSaRealize(MUT_SAID, false);
637 LocalAbilityManager::GetInstance().abilityMap_[MUT_SAID] = sysAby;
638 LocalAbilityManager::GetInstance().NotifyAbilityListener(SAID, MUT_SAID, deviceId, STARTCODE);
639 LocalAbilityManager::GetInstance().abilityMap_[SAID] = sysAby;
640 LocalAbilityManager::GetInstance().NotifyAbilityListener(SAID, MUT_SAID, deviceId, STARTCODE);
641 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProc(extension, SAID, &callback, isAsync);
642 EXPECT_TRUE(ret == ERR_NONE);
643 LocalAbilityManager::GetInstance().abilityMap_.clear();
644 delete sysAby;
645 }
646
647 /**
648 * @tc.name: SendStrategyToSAInner001
649 * @tc.desc: test SendStrategyToSAInner.
650 * @tc.type: FUNC
651 */
652 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner001, TestSize.Level2)
653 {
654 MessageParcel data;
655 MessageParcel reply;
656 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
657 EXPECT_EQ(ret, ERR_NULL_OBJECT);
658 }
659
660 /**
661 * @tc.name: SendStrategyToSAInner002
662 * @tc.desc: test SendStrategyToSAInner.
663 * @tc.type: FUNC
664 */
665 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner002, TestSize.Level2)
666 {
667 MessageParcel data;
668 MessageParcel reply;
669 int type = 1;
670 data.WriteInt32(type);
671 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
672 EXPECT_EQ(ret, ERR_NULL_OBJECT);
673 }
674
675 /**
676 * @tc.name: SendStrategyToSAInner003
677 * @tc.desc: test SendStrategyToSAInner.
678 * @tc.type: FUNC
679 */
680 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner003, TestSize.Level2)
681 {
682 MessageParcel data;
683 MessageParcel reply;
684 int type = 1;
685 data.WriteInt32(type);
686 int32_t saId = -1;
687 data.WriteInt32(saId);
688 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
689 EXPECT_EQ(ret, ERR_NULL_OBJECT);
690 }
691
692 /**
693 * @tc.name: SendStrategyToSAInner004
694 * @tc.desc: test SendStrategyToSAInner.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner004, TestSize.Level2)
698 {
699 MessageParcel data;
700 MessageParcel reply;
701 int type = 1;
702 data.WriteInt32(type);
703 int32_t saId = 1;
704 data.WriteInt32(saId);
705 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
706 EXPECT_EQ(ret, ERR_NULL_OBJECT);
707 }
708
709 /**
710 * @tc.name: SendStrategyToSAInner005
711 * @tc.desc: test SendStrategyToSAInner.
712 * @tc.type: FUNC
713 */
714 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner005, TestSize.Level2)
715 {
716 MessageParcel data;
717 MessageParcel reply;
718 int type = 1;
719 data.WriteInt32(type);
720 int32_t saId = 1;
721 data.WriteInt32(saId);
722 int level = 1;
723 data.WriteInt32(level);
724 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
725 EXPECT_EQ(ret, ERR_NULL_OBJECT);
726 }
727
728 /**
729 * @tc.name: SendStrategyToSAInner006
730 * @tc.desc: test SendStrategyToSAInner.
731 * @tc.type: FUNC
732 */
733 HWTEST_F(LocalAbilityManagerStubTest, SendStrategyToSAInner006, TestSize.Level2)
734 {
735 MessageParcel data;
736 MessageParcel reply;
737 int type = 1;
738 data.WriteInt32(type);
739 int32_t saId = 1;
740 data.WriteInt32(saId);
741 int level = 1;
742 data.WriteInt32(level);
743 std::string action = "";
744 data.WriteString(action);
745 int32_t ret = LocalAbilityManager::GetInstance().SendStrategyToSAInner(data, reply);
746 EXPECT_EQ(ret, ERR_NULL_OBJECT);
747 }
748
749 /**
750 * @tc.name: IpcStatCmdProcInner001
751 * @tc.desc: test IpcStatCmdProcInner.
752 * @tc.type: FUNC
753 */
754 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProcInner001, TestSize.Level2)
755 {
756 MessageParcel data;
757 MessageParcel reply;
758 int32_t ret = LocalAbilityManager::GetInstance().IpcStatCmdProcInner(data, reply);
759 EXPECT_EQ(ret, ERR_NULL_OBJECT);
760 }
761
762 /**
763 * @tc.name: IpcStatCmdProcInner002
764 * @tc.desc: test IpcStatCmdProcInner.
765 * @tc.type: FUNC
766 */
767 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProcInner002, TestSize.Level2)
768 {
769 MessageParcel data;
770 MessageParcel reply;
771 int32_t fd = 1;
772 data.WriteFileDescriptor(fd);
773 int32_t ret = LocalAbilityManager::GetInstance().IpcStatCmdProcInner(data, reply);
774 EXPECT_EQ(ret, ERR_NULL_OBJECT);
775 }
776
777 /**
778 * @tc.name: IpcStatCmdProcInner003
779 * @tc.desc: test IpcStatCmdProcInner.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(LocalAbilityManagerStubTest, IpcStatCmdProcInner003, TestSize.Level2)
783 {
784 MessageParcel data;
785 MessageParcel reply;
786 int32_t fd = 1;
787 int cmd = -1;
788 data.WriteInt32(cmd);
789 data.WriteFileDescriptor(fd);
790 int32_t ret = LocalAbilityManager::GetInstance().IpcStatCmdProcInner(data, reply);
791 EXPECT_EQ(ret, ERR_NULL_OBJECT);
792 }
793
794 /**
795 * @tc.name: FfrtDumperProcInner001
796 * @tc.desc: test IpcStatCmdProcInner.
797 * @tc.type: FUNC
798 */
799 HWTEST_F(LocalAbilityManagerStubTest, FfrtDumperProcInner001, TestSize.Level2)
800 {
801 MessageParcel data;
802 MessageParcel reply;
803 std::string ffrtDumperInfo = "Test Ffrt Dumper Info";
804 int32_t ret = LocalAbilityManager::GetInstance().FfrtDumperProcInner(data, reply);
805 EXPECT_EQ(ret, ERR_NONE);
806 }
807
808 /**
809 * @tc.name: SystemAbilityExtProcInner001
810 * @tc.desc: test IpcStatCmdProcInner.
811 * @tc.type: FUNC
812 */
813 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProcInner001, TestSize.Level2)
814 {
815 MessageParcel data;
816 MessageParcel reply;
817 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProcInner(data, reply);
818 EXPECT_EQ(ret, INVALID_DATA);
819 }
820
821 /**
822 * @tc.name: SystemAbilityExtProcInner002
823 * @tc.desc: test IpcStatCmdProcInner.
824 * @tc.type: FUNC
825 */
826 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProcInner002, TestSize.Level2)
827 {
828 MessageParcel data;
829 MessageParcel reply;
830 int saId = 1;
831 data.WriteInt32(saId);
832 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProcInner(data, reply);
833 EXPECT_EQ(ret, INVALID_DATA);
834 }
835
836 /**
837 * @tc.name: SystemAbilityExtProcInner003
838 * @tc.desc: test IpcStatCmdProcInner.
839 * @tc.type: FUNC
840 */
841 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProcInner003, TestSize.Level2)
842 {
843 MessageParcel data;
844 MessageParcel reply;
845 int saId = -1;
846 data.WriteInt32(saId);
847 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProcInner(data, reply);
848 EXPECT_EQ(ret, INVALID_DATA);
849 }
850
851 /**
852 * @tc.name: SystemAbilityExtProcInner004
853 * @tc.desc: test IpcStatCmdProcInner.
854 * @tc.type: FUNC
855 */
856 HWTEST_F(LocalAbilityManagerStubTest, SystemAbilityExtProcInner004, TestSize.Level2)
857 {
858 MessageParcel data;
859 MessageParcel reply;
860 int saId = 1;
861 data.WriteInt32(saId);
862 std::string extension = "TestExtension";
863 data.WriteString(extension);
864 int32_t ret = LocalAbilityManager::GetInstance().SystemAbilityExtProcInner(data, reply);
865 EXPECT_EQ(ret, INVALID_DATA);
866 }
867 } // namespace SAFWK
868 } // namespace OHOS