1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "gtest/gtest.h"
16 #include "iservice_registry.h"
17 #include "local_ability_manager_stub.h"
18 #include "memory"
19 #include "sa_mock_permission.h"
20 #include "test_log.h"
21
22 #define private public
23 #define protected public
24 #include "local_ability_manager.h"
25 #include "mock_sa_realize.h"
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace SAFWK {
31 namespace {
32 constexpr int32_t SAID = 1489;
33 const std::string TEST_STRING = "test";
34 const std::string EVENT_NAME = "name";
35 const std::string EVENT_ID = "eventId";
36 const std::string TEST_RESOURCE_PATH = "/data/test/resource/samgr/profile/";
37 constexpr int32_t LISTENER_ID = 1488;
38 constexpr int32_t MOCK_DEPEND_TIMEOUT = 1000;
39 }
40
41 class MockLocalAbilityManager : public LocalAbilityManagerStub {
42 public:
43 MockLocalAbilityManager() = default;
44 ~MockLocalAbilityManager() = default;
45
46 bool StartAbility(int32_t systemAbilityId, const std::string& eventStr) override;
47 bool StopAbility(int32_t systemAbilityId, const std::string& eventStr) override;
48 bool ActiveAbility(int32_t systemAbilityId,
49 const nlohmann::json& activeReason) override;
50 bool IdleAbility(int32_t systemAbilityId,
51 const nlohmann::json& idleReason, int32_t& delayTime) override;
52 bool SendStrategyToSA(int32_t type, int32_t systemAbilityId,
53 int32_t level, std::string& action) override;
54 bool IpcStatCmdProc(int32_t fd, int32_t cmd) override;
55 bool FfrtDumperProc(std::string& ffrtdumpinfo) override;
56 int32_t SystemAbilityExtProc(const std::string& extension, int32_t said,
57 SystemAbilityExtensionPara* callback, bool isAsync) override;
58 };
59 class SystemAbilityTest : public testing::Test {
60 public:
61 static void SetUpTestCase();
62 static void TearDownTestCase();
63 void SetUp();
64 void TearDown();
65 };
66
SetUpTestCase()67 void SystemAbilityTest::SetUpTestCase()
68 {
69 DTEST_LOG << "SetUpTestCase" << std::endl;
70 }
71
TearDownTestCase()72 void SystemAbilityTest::TearDownTestCase()
73 {
74 DTEST_LOG << "TearDownTestCase" << std::endl;
75 }
76
SetUp()77 void SystemAbilityTest::SetUp()
78 {
79 SaMockPermission::MockPermission();
80 DTEST_LOG << "SetUp" << std::endl;
81 }
82
TearDown()83 void SystemAbilityTest::TearDown()
84 {
85 DTEST_LOG << "TearDown" << std::endl;
86 }
87
StartAbility(int32_t systemAbilityId,const std::string & eventStr)88 bool MockLocalAbilityManager::StartAbility(int32_t systemAbilityId, const std::string& eventStr)
89 {
90 DTEST_LOG << "said : " << systemAbilityId <<std::endl;
91 return true;
92 }
93
StopAbility(int32_t systemAbilityId,const std::string & eventStr)94 bool MockLocalAbilityManager::StopAbility(int32_t systemAbilityId, const std::string& eventStr)
95 {
96 DTEST_LOG << "said : " << systemAbilityId <<std::endl;
97 return true;
98 }
99
ActiveAbility(int32_t systemAbilityId,const nlohmann::json & activeReason)100 bool MockLocalAbilityManager::ActiveAbility(int32_t systemAbilityId,
101 const nlohmann::json& activeReason)
102 {
103 DTEST_LOG << "said : " << systemAbilityId <<std::endl;
104 return true;
105 }
106
IdleAbility(int32_t systemAbilityId,const nlohmann::json & idleReason,int32_t & delayTime)107 bool MockLocalAbilityManager::IdleAbility(int32_t systemAbilityId,
108 const nlohmann::json& idleReason, int32_t& delayTime)
109 {
110 DTEST_LOG << "said : " << systemAbilityId <<std::endl;
111 return true;
112 }
113
SendStrategyToSA(int32_t type,int32_t systemAbilityId,int32_t level,std::string & action)114 bool MockLocalAbilityManager::SendStrategyToSA(int32_t type, int32_t systemAbilityId,
115 int32_t level, std::string& action)
116 {
117 DTEST_LOG << "said : " << systemAbilityId <<std::endl;
118 return true;
119 }
120
IpcStatCmdProc(int32_t fd,int32_t cmd)121 bool MockLocalAbilityManager::IpcStatCmdProc(int32_t fd, int32_t cmd)
122 {
123 DTEST_LOG << "fd : " << fd <<std::endl;
124 DTEST_LOG << "cmd : " << cmd <<std::endl;
125 return true;
126 }
127
FfrtDumperProc(std::string & ffrtDumpInfo)128 bool MockLocalAbilityManager::FfrtDumperProc(std::string& ffrtDumpInfo)
129 {
130 DTEST_LOG << "FfrtDumperProc" <<std::endl;
131 return true;
132 }
133
SystemAbilityExtProc(const std::string & extension,int32_t said,SystemAbilityExtensionPara * callback,bool isAsync)134 int32_t MockLocalAbilityManager::SystemAbilityExtProc(const std::string& extension, int32_t said,
135 SystemAbilityExtensionPara* callback, bool isAsync)
136 {
137 DTEST_LOG << "said : " << said <<std::endl;
138 return 0;
139 }
140
141 /**
142 * @tc.name: RemoveSystemAbilityListener001
143 * @tc.desc: Check RemoveSystemAbilityListener
144 * @tc.type: FUNC
145 * @tc.require: I5KMF7
146 */
147 HWTEST_F(SystemAbilityTest, RemoveSystemAbilityListener001, TestSize.Level2)
148 {
149 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
150 sysAby->AddSystemAbilityListener(LISTENER_ID);
151 bool res = sysAby->RemoveSystemAbilityListener(LISTENER_ID);
152 EXPECT_EQ(res, true);
153 }
154
155 /**
156 * @tc.name: MakeAndRegisterAbility001
157 * @tc.desc: Check MakeAndRegisterAbility
158 * @tc.type: FUNC
159 * @tc.require: I5KMF7
160 */
161 HWTEST_F(SystemAbilityTest, MakeAndRegisterAbility001, TestSize.Level2)
162 {
163 bool res = SystemAbility::MakeAndRegisterAbility(new MockSaRealize(SAID, false));
164 EXPECT_EQ(res, false);
165 }
166
167 /**
168 * @tc.name: MakeAndRegisterAbility002
169 * @tc.desc: Check MakeAndRegisterAbility
170 * @tc.type: FUNC
171 * @tc.require: I5KMF7
172 */
173 HWTEST_F(SystemAbilityTest, MakeAndRegisterAbility002, TestSize.Level2)
174 {
175 bool ret = LocalAbilityManager::GetInstance().profileParser_->ParseSaProfiles(TEST_RESOURCE_PATH + "1489.json");
176 EXPECT_EQ(ret, true);
177 bool res = SystemAbility::MakeAndRegisterAbility(new MockSaRealize(SAID, false));
178 EXPECT_EQ(res, true);
179 }
180
181 /**
182 * @tc.name: Publish001
183 * @tc.desc: Verify Publish when systemabitly is nullptr
184 * @tc.type: FUNC
185 * @tc.require: I5KMF7
186 */
187 HWTEST_F(SystemAbilityTest, Publish001, TestSize.Level2)
188 {
189 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
190 bool ret = sysAby->Publish(nullptr);
191 EXPECT_FALSE(ret);
192 }
193
194 /**
195 * @tc.name: Publish002
196 * @tc.desc: Verify Publish function
197 * @tc.type: FUNC
198 * @tc.require: I5KMF7
199 */
200 HWTEST_F(SystemAbilityTest, Publish002, TestSize.Level2)
201 {
202 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
203 sptr<IRemoteObject> obj(new MockLocalAbilityManager());
204 bool ret = sysAby->Publish(obj);
205 ASSERT_TRUE(ret);
206 sysAby->Stop();
207 sysAby->StopAbility(-1);
208 sysAby->Start();
209 sysAby->Stop();
210 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::NOT_LOADED);
211 }
212
213 /**
214 * @tc.name: SetDependTimeout001
215 * @tc.desc: Verify SetDependTimeout
216 * @tc.type: FUNC
217 * @tc.require: I5KMF7
218 */
219 HWTEST_F(SystemAbilityTest, SetDependTimeout001, TestSize.Level2)
220 {
221 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
222 sysAby->SetDependTimeout(0);
223 sysAby->SetDependTimeout(MOCK_DEPEND_TIMEOUT);
224 EXPECT_EQ(sysAby->GetDependTimeout(), MOCK_DEPEND_TIMEOUT);
225 }
226
227 /**
228 * @tc.name: GetSystemAbility001
229 * @tc.desc: Check GetSystemAbility
230 * @tc.type: FUNC
231 * @tc.require: I5KMF7
232 */
233 HWTEST_F(SystemAbilityTest, GetSystemAbility001, TestSize.Level2)
234 {
235 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
236 sptr<IRemoteObject> obj = sysAby->GetSystemAbility(-1);
237 EXPECT_TRUE(obj == nullptr);
238 }
239
240 /**
241 * @tc.name: CancelIdle001
242 * @tc.desc: test CancelIdle with abilityState_ is not SystemAbilityState::IDLE
243 * @tc.type: FUNC
244 * @tc.require:I6LSSX
245 */
246 HWTEST_F(SystemAbilityTest, CancelIdle001, TestSize.Level2)
247 {
248 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
249 sysAby->abilityState_ = SystemAbilityState::NOT_LOADED;
250 int32_t ret = sysAby->CancelIdle();
251 EXPECT_TRUE(ret);
252 }
253
254 /**
255 * @tc.name: CancelIdle002
256 * @tc.desc: test CancelIdle with abilityState_ is SystemAbilityState::IDLE
257 * @tc.type: FUNC
258 * @tc.require:I6LSSX
259 */
260 HWTEST_F(SystemAbilityTest, CancelIdle002, TestSize.Level2)
261 {
262 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
263 sysAby->abilityState_ = SystemAbilityState::IDLE;
264 int32_t ret = sysAby->CancelIdle();
265 EXPECT_FALSE(ret);
266 }
267
268 /**
269 * @tc.name: Start001
270 * @tc.desc: test Start with abilityState_ is not SystemAbilityState::NOT_LOADED
271 * @tc.type: FUNC
272 * @tc.require:I6LSSX
273 */
274 HWTEST_F(SystemAbilityTest, Start001, TestSize.Level2)
275 {
276 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
277 sysAby->abilityState_ = SystemAbilityState::IDLE;
278 sysAby->Start();
279 EXPECT_FALSE(sysAby->isRunning_);
280 }
281
282 /**
283 * @tc.name: Start002
284 * @tc.desc: test Start with is SystemAbilityState::NOT_LOADED
285 * @tc.type: FUNC
286 * @tc.require:I6LSSX
287 */
288 HWTEST_F(SystemAbilityTest, Start002, TestSize.Level2)
289 {
290 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
291 sysAby->abilityState_ = SystemAbilityState::NOT_LOADED;
292 sysAby->Start();
293 EXPECT_TRUE(sysAby->isRunning_);
294 }
295
296 /**
297 * @tc.name: Idle001
298 * @tc.desc: test Idle with abilityState_ is not SystemAbilityState::ACTIVE
299 * @tc.type: FUNC
300 * @tc.require:I6LSSX
301 */
302 HWTEST_F(SystemAbilityTest, Idle001, TestSize.Level2)
303 {
304 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
305 sysAby->abilityState_ = SystemAbilityState::IDLE;
306 SystemAbilityOnDemandReason idleReason;
307 int32_t delayTime = 123;
308 sysAby->Idle(idleReason, delayTime);
309 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::IDLE);
310 }
311
312 /**
313 * @tc.name: Idle002
314 * @tc.desc: test Idle with abilityState_ is SystemAbilityState::ACTIVE and delayTime is 0
315 * @tc.type: FUNC
316 * @tc.require:I6LSSX
317 */
318 HWTEST_F(SystemAbilityTest, Idle002, TestSize.Level2)
319 {
320 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
321 sysAby->abilityState_ = SystemAbilityState::ACTIVE;
322 SystemAbilityOnDemandReason idleReason;
323 idleReason.SetId(OnDemandReasonId::DEVICE_ONLINE);
324 int32_t noDelayTime = 0;
325 sysAby->Idle(idleReason, noDelayTime);
326 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::IDLE);
327 }
328
329 /**
330 * @tc.name: Idle003
331 * @tc.desc: test Idle with abilityState_ is SystemAbilityState::ACTIVE and delayTime is 0
332 * @tc.type: FUNC
333 * @tc.require:I6LSSX
334 */
335 HWTEST_F(SystemAbilityTest, Idle003, TestSize.Level2)
336 {
337 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
338 sysAby->abilityState_ = SystemAbilityState::ACTIVE;
339 SystemAbilityOnDemandReason idleReason;
340 idleReason.SetId(OnDemandReasonId::DEVICE_ONLINE);
341 int32_t delayTime = 123;
342 sysAby->Idle(idleReason, delayTime);
343 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::IDLE);
344 }
345
346 /**
347 * @tc.name: Active001
348 * @tc.desc: test Active with abilityState_ is not SystemAbilityState::IDLE
349 * @tc.type: FUNC
350 * @tc.require:I6LSSX
351 */
352 HWTEST_F(SystemAbilityTest, Active001, TestSize.Level2)
353 {
354 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
355 sysAby->abilityState_ = SystemAbilityState::ACTIVE;
356 SystemAbilityOnDemandReason activeReason;
357 sysAby->Active(activeReason);
358 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::ACTIVE);
359 }
360
361 /**
362 * @tc.name: Active002
363 * @tc.desc: test Active with abilityState_ is SystemAbilityState::IDLE
364 * @tc.type: FUNC
365 * @tc.require:I6LSSX
366 */
367 HWTEST_F(SystemAbilityTest, Active002, TestSize.Level2)
368 {
369 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
370 sysAby->abilityState_ = SystemAbilityState::IDLE;
371 SystemAbilityOnDemandReason activeReason;
372 activeReason.SetId(OnDemandReasonId::DEVICE_ONLINE);
373 sysAby->Active(activeReason);
374 EXPECT_EQ(sysAby->abilityState_, SystemAbilityState::ACTIVE);
375 }
376
377 /**
378 * @tc.name: GetLibPath001
379 * @tc.desc: Check GetLibPath,cover function
380 * @tc.type: FUNC
381 * @tc.require:I6LSSX
382 */
383 HWTEST_F(SystemAbilityTest, GetLibPath001, TestSize.Level2)
384 {
385 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
386 sysAby->libPath_ = TEST_RESOURCE_PATH;
387 EXPECT_EQ(sysAby->libPath_, TEST_RESOURCE_PATH);
388 }
389
390 /**
391 * @tc.name: IsRunOnCreate001
392 * @tc.desc: Check IsRunOnCreate,cover function
393 * @tc.type: FUNC
394 * @tc.require:I6LSSX
395 */
396 HWTEST_F(SystemAbilityTest, IsRunOnCreate001, TestSize.Level2)
397 {
398 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
399 sysAby->isRunOnCreate_ = true;
400 EXPECT_TRUE(sysAby->isRunOnCreate_);
401 }
402
403 /**
404 * @tc.name: OnIdle001
405 * @tc.desc: Check OnIdle,cover function
406 * @tc.type: FUNC
407 * @tc.require:I6LSSX
408 */
409 HWTEST_F(SystemAbilityTest, OnIdle001, TestSize.Level2)
410 {
411 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
412 SystemAbilityOnDemandReason idleReason;
413 int32_t ret = sysAby->OnIdle(idleReason);
414 EXPECT_EQ(ret, 0);
415 }
416
417 /**
418 * @tc.name: GetCapability001
419 * @tc.desc: Check GetCapability, cover function
420 * @tc.type: FUNC
421 * @tc.require: I73XRZ
422 */
423 HWTEST_F(SystemAbilityTest, GetCapability001, TestSize.Level2)
424 {
425 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
426 sysAby->OnDump();
427 std::u16string capability;
428 auto ret = sysAby->GetCapability();
429 EXPECT_EQ(ret, capability);
430 }
431
432 /**
433 * @tc.name: GetAbilityState001
434 * @tc.desc: Check GetAbilityState, cover function
435 * @tc.type: FUNC
436 * @tc.require: I73XRZ
437 */
438 HWTEST_F(SystemAbilityTest, GetAbilityState001, TestSize.Level2)
439 {
440 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
441 SystemAbilityState ret = sysAby->GetAbilityState();
442 EXPECT_EQ(ret, SystemAbilityState::NOT_LOADED);
443 }
444
445 /**
446 * @tc.name: IsRunOnCreate002
447 * @tc.desc: Check IsRunOnCreate, cover function
448 * @tc.type: FUNC
449 * @tc.require: I73XRZ
450 */
451 HWTEST_F(SystemAbilityTest, IsRunOnCreate002, TestSize.Level2)
452 {
453 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
454 bool ret = sysAby->IsRunOnCreate();
455 EXPECT_FALSE(ret);
456 }
457
458 /**
459 * @tc.name: GetLibPath002
460 * @tc.desc: Check GetLibPath, cover function
461 * @tc.type: FUNC
462 * @tc.require: I73XRZ
463 */
464 HWTEST_F(SystemAbilityTest, GetLibPath002, TestSize.Level2)
465 {
466 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
467 sysAby->SADump();
468 SystemAbilityOnDemandReason onDemandStartReason;
469 sysAby->GetOnDemandReasonExtraData(onDemandStartReason);
470 std::string capability;
471 auto ret = sysAby->GetLibPath();
472 EXPECT_EQ(ret, capability);
473 }
474
475 /**
476 * @tc.name: GetOnDemandReasonExtraData001
477 * @tc.desc: Check GetOnDemandReasonExtraData
478 * @tc.type: FUNC
479 * @tc.require: I73XRZ
480 */
481 HWTEST_F(SystemAbilityTest, GetOnDemandReasonExtraData001, TestSize.Level2)
482 {
483 std::shared_ptr<SystemAbility> sysAby = std::make_shared<MockSaRealize>(SAID, false);
484 SystemAbilityOnDemandReason onDemandStartReason;
485 onDemandStartReason.reasonId_ = OHOS::OnDemandReasonId::COMMON_EVENT;
486 sysAby->GetOnDemandReasonExtraData(onDemandStartReason);
487 EXPECT_TRUE(onDemandStartReason.HasExtraData());
488 }
489 }
490 }