1 /*
2 * Copyright (c) 2021-2023 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 <climits>
17 #include <gtest/gtest.h>
18 #include "ability_thread.h"
19 #include "ability_local_record.h"
20 #include "ability_loader.h"
21 #include "ability_impl_factory.h"
22 #include "data_ability_helper.h"
23 #include "context_deal.h"
24 #ifndef SUPPORT_ERMS
25 #include "erms_mgr_interface.h"
26 #endif
27 #include "ohos_application.h"
28 #include "sys_mgr_client.h"
29 #include "ability_manager_interface.h"
30 #include "ability_manager_client.h"
31 #include "system_ability_definition.h"
32 #include "demo_ability_test.h"
33 #include "mock_bundle_manager.h"
34 #include "mock_ability_manager_service.h"
35
36 namespace OHOS {
37 namespace AppExecFwk {
38 using namespace testing::ext;
39 using namespace OHOS;
40 using namespace AAFwk;
41 using OHOS::AppExecFwk::ElementName;
42 using namespace OHOS::AppExecFwk;
43 /*
44 * Parameters:
45 * Action
46 * Entity
47 * Flag
48 * ElementName
49 */
50 const std::string ABILITY_NAME("DemoAbility");
51 class AbilityBaseTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 OHOS::sptr<OHOS::IRemoteObject> abilityObject_;
58 static constexpr int TEST_WAIT_TIME = 500 * 1000; // 500 ms
59 static const int RESULT_CODE = 1992;
60 };
61
SetUpTestCase(void)62 void AbilityBaseTest::SetUpTestCase(void)
63 {}
64
TearDownTestCase(void)65 void AbilityBaseTest::TearDownTestCase(void)
66 {}
67
68 #ifndef SUPPORT_ERMS
69 class TestIEcologicalRuleManager : public AppExecFwk::IEcologicalRuleManager {
70 public:
71 TestIEcologicalRuleManager() = default;
~TestIEcologicalRuleManager()72 virtual ~TestIEcologicalRuleManager()
73 {};
AsObject()74 sptr<IRemoteObject> AsObject() override
75 {
76 return nullptr;
77 }
78 };
79 #endif
80
SetUp(void)81 void AbilityBaseTest::SetUp(void)
82 {
83 abilityObject_ = new MockAbilityManagerService();
84 auto sysMgr = OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance();
85 EXPECT_TRUE(sysMgr != nullptr);
86 sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject_);
87 sysMgr->RegisterSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
88 }
89
TearDown(void)90 void AbilityBaseTest::TearDown(void)
91 {
92 abilityObject_ = nullptr;
93 }
94
95 /**
96 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0100
97 * @tc.name: AbilityFwk Start
98 * @tc.desc: The first step of startability is the attach AMS.
99 */
100 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0100, Function | MediumTest | Level1)
101 {
102 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
103
104 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
105 EXPECT_NE(abilityToken, nullptr);
106 if (abilityToken != nullptr) {
107 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
108 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
109 abilityInfo->name = ABILITY_NAME;
110 abilityInfo->isNativeAbility = true;
111 std::shared_ptr<AbilityLocalRecord> abilityRecord =
112 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
113
114 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
115 usleep(AbilityBaseTest::TEST_WAIT_TIME);
116 }
117 }
118
119 /**
120 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0200
121 * @tc.name: AbilityFwk Start
122 * @tc.desc: When connecting AMS,the instance of application is empty.
123 */
124 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0200, Function | MediumTest | Level1)
125 {
126 std::shared_ptr<OHOSApplication> application = nullptr;
127
128 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
129 EXPECT_NE(abilityToken, nullptr);
130 if (abilityToken != nullptr) {
131 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
132 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
133 abilityInfo->name = ABILITY_NAME;
134 abilityInfo->isNativeAbility = true;
135 std::shared_ptr<AbilityLocalRecord> abilityRecord =
136 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
137
138 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
139 usleep(AbilityBaseTest::TEST_WAIT_TIME);
140 }
141 }
142
143 /**
144 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0300
145 * @tc.name: AbilityFwk Start
146 * @tc.desc: When connecting AMS,the instance of abilityRecord is empty
147 */
148 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0300, Function | MediumTest | Level1)
149 {
150 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
151
152 std::shared_ptr<AbilityLocalRecord> abilityRecord = nullptr;
153
154 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
155 usleep(AbilityBaseTest::TEST_WAIT_TIME);
156 }
157
158 /**
159 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0400
160 * @tc.name: AbilityFwk Start
161 * @tc.desc: The ability name is empty, so the ability instance cannot be created.
162 */
163 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0400, Function | MediumTest | Level1)
164 {
165 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
166
167 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
168 EXPECT_NE(abilityToken, nullptr);
169 if (abilityToken != nullptr) {
170 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
171 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
172 std::shared_ptr<AbilityLocalRecord> abilityRecord =
173 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
174
175 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
176 usleep(AbilityBaseTest::TEST_WAIT_TIME);
177 }
178 }
179
180 /**
181 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0500
182 * @tc.name: AbilityFwk Start
183 * @tc.desc: The ability type is unknown, so the AbilityImpl instance cannot be created.
184 */
185 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0500, Function | MediumTest | Level1)
186 {
187 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
188
189 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
190 EXPECT_NE(abilityToken, nullptr);
191 if (abilityToken != nullptr) {
192 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
193 abilityInfo->name = ABILITY_NAME;
194 abilityInfo->isNativeAbility = true;
195 std::shared_ptr<AbilityLocalRecord> abilityRecord =
196 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
197
198 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
199 usleep(AbilityBaseTest::TEST_WAIT_TIME);
200 }
201 }
202
203 /**
204 * @tc.number: AaFwk_Ability_AbilityFwk_Start_Test_0600
205 * @tc.name: AbilityFwk Start
206 * @tc.desc: The interface OnSaveAbilityState()/OnRestoreAbilityState() of demoability was called.
207 */
208 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Start_Test_0600, Function | MediumTest | Level1)
209 {
210 std::shared_ptr<ContextDeal> contextDeal = std::make_shared<ContextDeal>();
211 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
212 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
213 std::shared_ptr<ProcessInfo> processInfo = std::make_shared<ProcessInfo>();
214
215 appInfo->codePath = "codePath";
216 appInfo->dataBaseDir = "dataBaseDir";
217 appInfo->dataDir = "dataDir";
218 appInfo->cacheDir = "cacheDir";
219 appInfo->bundleName = "bundleName";
220
221 application->SetProcessInfo(processInfo);
222 contextDeal->SetApplicationInfo(appInfo);
223 contextDeal->SetApplicationContext(application);
224 application->AttachBaseContext(contextDeal);
225
226 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
227 EXPECT_NE(abilityToken, nullptr);
228 if (abilityToken != nullptr) {
229 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
230 abilityInfo->codePath = "codePath";
231 abilityInfo->resourcePath = "resourcePath";
232
233 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
234 abilityInfo->name = ABILITY_NAME;
235 abilityInfo->isNativeAbility = true;
236 std::shared_ptr<AbilityLocalRecord> abilityRecord =
237 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
238
239 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
240
241 sptr<IRemoteObject> remoteObject_ =
242 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
243 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
244 Want want;
245 sptr<IAbilityConnection> connect = nullptr;
246
247 // Just to test two interfaces OnRestoreAbilityState/OnSaveAbilityState
248 abms->ConnectAbility(want, connect, abilityToken);
249 usleep(AbilityBaseTest::TEST_WAIT_TIME);
250 }
251 }
252
253 /**
254 * @tc.number: AaFwk_Ability_Lifecycle_Test_0100
255 * @tc.name: Ability Lifecycle
256 * @tc.desc: The ability life cycle will change from initial state initial to inactive by calling the interface
257 * OnnStart(), and then to active by calling OnActive().
258 */
259 HWTEST_F(AbilityBaseTest, AaFwk_Ability_Lifecycle_Test_0100, Function | MediumTest | Level1)
260 {
261 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
262
263 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
264 EXPECT_NE(abilityToken, nullptr);
265 if (abilityToken != nullptr) {
266 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
267 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
268 abilityInfo->name = ABILITY_NAME;
269 abilityInfo->isNativeAbility = true;
270 std::shared_ptr<AbilityLocalRecord> abilityRecord =
271 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
272
273 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
274
275 sptr<IRemoteObject> remoteObject_ =
276 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
277 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
278 Want want;
279 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
280 usleep(AbilityBaseTest::TEST_WAIT_TIME);
281 }
282 }
283
284 /**
285 * @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0200
286 * @tc.name: Ability Lifecycle
287 * @tc.desc: The ability life cycle will change from initial state initial to inactive by calling the interface
288 * OnnStart(), and then to active by calling OnNewWant()+OnActive().
289 */
290 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0200, Function | MediumTest | Level1)
291 {
292 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
293
294 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
295 EXPECT_NE(abilityToken, nullptr);
296 if (abilityToken != nullptr) {
297 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
298 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
299 abilityInfo->name = ABILITY_NAME;
300 abilityInfo->isNativeAbility = true;
301 std::shared_ptr<AbilityLocalRecord> abilityRecord =
302 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
303
304 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
305
306 sptr<IRemoteObject> remoteObject_ =
307 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
308 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
309
310 abms->DisconnectAbility(nullptr);
311 usleep(AbilityBaseTest::TEST_WAIT_TIME);
312 }
313 }
314
315 /**
316 * @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0300
317 * @tc.name: Ability Lifecycle
318 * @tc.desc: Ability life cycle changes: initial - > active - > background, the interface of demoability will be
319 called:
320 * OnStart()->OnActive()->OnInactive()->OnBackground().
321 */
322 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0300, Function | MediumTest | Level1)
323 {
324 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
325
326 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
327 EXPECT_NE(abilityToken, nullptr);
328 if (abilityToken != nullptr) {
329 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
330 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
331 abilityInfo->name = ABILITY_NAME;
332 abilityInfo->isNativeAbility = true;
333 std::shared_ptr<AbilityLocalRecord> abilityRecord =
334 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
335
336 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
337
338 sptr<IRemoteObject> remoteObject_ =
339 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
340 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
341 Want want;
342
343 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
344 usleep(AbilityBaseTest::TEST_WAIT_TIME);
345 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
346 usleep(AbilityBaseTest::TEST_WAIT_TIME);
347 }
348 }
349
350 /**
351 * @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0400
352 * @tc.name: Ability Lifecycle
353 * @tc.desc: Ability life cycle changes: initial - > active - > inactive, the interface of demoability will be
354 called:
355 * OnStart()->OnActive()->OnInactive().
356 */
357 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0400, Function | MediumTest | Level1)
358 {
359 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
360
361 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
362 EXPECT_NE(abilityToken, nullptr);
363 if (abilityToken != nullptr) {
364 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
365 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
366 abilityInfo->name = ABILITY_NAME;
367 abilityInfo->isNativeAbility = true;
368 std::shared_ptr<AbilityLocalRecord> abilityRecord =
369 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
370
371 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
372
373 sptr<IRemoteObject> remoteObject_ =
374 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
375 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
376 Want want;
377
378 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
379 usleep(AbilityBaseTest::TEST_WAIT_TIME);
380 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
381 usleep(AbilityBaseTest::TEST_WAIT_TIME);
382 }
383 }
384
385 /**
386 * @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0500
387 * @tc.name: Ability Lifecycle
388 * @tc.desc: Ability life cycle changes: initial - > active , the interface of demoability will be called:
389 * OnStart()->OnActive()->OnInactive()->OnBackground()->OnForeground().
390 */
391 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0500, Function | MediumTest | Level1)
392 {
393 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
394
395 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
396 EXPECT_NE(abilityToken, nullptr);
397 if (abilityToken != nullptr) {
398 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
399 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
400 abilityInfo->name = ABILITY_NAME;
401 abilityInfo->isNativeAbility = true;
402 std::shared_ptr<AbilityLocalRecord> abilityRecord =
403 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
404
405 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
406
407 sptr<IRemoteObject> remoteObject_ =
408 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
409 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
410 Want want;
411
412 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
413 usleep(AbilityBaseTest::TEST_WAIT_TIME);
414 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
415 usleep(AbilityBaseTest::TEST_WAIT_TIME);
416 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
417 usleep(AbilityBaseTest::TEST_WAIT_TIME);
418 }
419 }
420
421 /**
422 * @tc.number: AaFwk_Ability_AbilityFwk_Lifecycle_Test_0600
423 * @tc.name: Ability Lifecycle
424 * @tc.desc: Ability life cycle changes: initial - > active , the interface of demoability will be called:
425 * OnStart()->OnActive()->OnInactive()->OnBackground()->OnStop().
426 */
427 HWTEST_F(AbilityBaseTest, AaFwk_Ability_AbilityFwk_Lifecycle_Test_0600, Function | MediumTest | Level1)
428 {
429 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
430
431 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
432 EXPECT_NE(abilityToken, nullptr);
433 if (abilityToken != nullptr) {
434 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
435 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
436 abilityInfo->name = ABILITY_NAME;
437 abilityInfo->isNativeAbility = true;
438 std::shared_ptr<AbilityLocalRecord> abilityRecord =
439 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
440
441 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
442
443 sptr<IRemoteObject> remoteObject_ =
444 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
445 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
446 Want want;
447
448 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
449 usleep(AbilityBaseTest::TEST_WAIT_TIME);
450 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
451 usleep(AbilityBaseTest::TEST_WAIT_TIME);
452 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
453 usleep(AbilityBaseTest::TEST_WAIT_TIME);
454 }
455 }
456
457 /**
458 * @tc.number: AaFwk_Ability_TerminateAbility_ForResult_Test_0100
459 * @tc.name: TerminateAbility_ForResult
460 * @tc.desc: 1. TerminateAbility with parameters
461 * 2. AMS returns parameters through sendresult
462 * 3. Compare the returned parameters with the passed in parameters.
463 */
464 HWTEST_F(AbilityBaseTest, AaFwk_Ability_TerminateAbility_ForResult_Test_0100, Function | MediumTest | Level1)
465 {
466 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
467
468 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
469 EXPECT_NE(abilityToken, nullptr);
470 if (abilityToken != nullptr) {
471 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
472 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
473 abilityInfo->name = ABILITY_NAME;
474 abilityInfo->isNativeAbility = true;
475 std::shared_ptr<AbilityLocalRecord> abilityRecord =
476 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
477
478 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
479
480 sptr<IRemoteObject> remoteObject_ =
481 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
482 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
483 Want want;
484 sptr<IAbilityConnection> connect = nullptr;
485
486 abms->TerminateAbility(nullptr, RESULT_CODE, &want);
487 usleep(AbilityBaseTest::TEST_WAIT_TIME);
488 }
489 }
490
491 /*
492 * Parameters:
493 * Action
494 * Entity
495 * Flag
496 * ElementName
497 */
498 class AbilityTerminateTest : public testing::Test {
499 public:
500 static void SetUpTestCase(void);
501 static void TearDownTestCase(void);
502 void SetUp();
503 void TearDown();
504
505 public:
506 OHOS::sptr<OHOS::IRemoteObject> abilityObject_;
507 static constexpr int TEST_WAIT_TIME = 500 * 1000; // 500 ms
508 static const int RESULT_CODE = 1992;
509 };
510
SetUpTestCase(void)511 void AbilityTerminateTest::SetUpTestCase(void)
512 {}
513
TearDownTestCase(void)514 void AbilityTerminateTest::TearDownTestCase(void)
515 {}
516
SetUp(void)517 void AbilityTerminateTest::SetUp(void)
518 {
519 abilityObject_ = new MockAbilityManagerService();
520 auto sysMgr = OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance();
521 EXPECT_TRUE(sysMgr != nullptr);
522 sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject_);
523 }
524
TearDown(void)525 void AbilityTerminateTest::TearDown(void)
526 {
527 abilityObject_ = nullptr;
528 }
529
530 /**
531 * @tc.number: AaFwk_Ability_Terminate_test_0100
532 * @tc.name: TerminateAbility
533 * @tc.desc: When the ability state is inactive, the call to terminateability terminates.
534 */
535 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0100, Function | MediumTest | Level1)
536 {
537 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
538 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
539 EXPECT_NE(abilityToken, nullptr);
540 if (abilityToken != nullptr) {
541 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
542 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
543 abilityInfo->name = ABILITY_NAME;
544 abilityInfo->isNativeAbility = true;
545 std::shared_ptr<AbilityLocalRecord> abilityRecord =
546 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
547
548 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_001 AbilityThreadMain";
549 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
550
551 Want want;
552 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
553 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
554 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
555
556 auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
557 EXPECT_NE(ability, nullptr);
558 if (ability != nullptr) {
559 ability->SetResult(RESULT_CODE, want);
560 ability->TerminateAbility();
561 }
562 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
563 }
564 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_001 TerminateAbility";
565 }
566
567 /**
568 * @tc.number: AaFwk_Ability_Terminate_test_0200
569 * @tc.name: TerminateAbility
570 * @tc.desc: When the ability state is active, the call to terminateability terminates.
571 */
572 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0200, Function | MediumTest | Level1)
573 {
574 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
575 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
576 EXPECT_NE(abilityToken, nullptr);
577 if (abilityToken != nullptr) {
578 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
579 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
580 abilityInfo->name = ABILITY_NAME;
581 abilityInfo->isNativeAbility = true;
582 std::shared_ptr<AbilityLocalRecord> abilityRecord =
583 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
584
585 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_002 AbilityThreadMain";
586 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
587
588 Want want;
589 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
590 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
591 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
592
593 auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
594 EXPECT_NE(ability, nullptr);
595 if (ability != nullptr) {
596 ability->SetResult(RESULT_CODE, want);
597 ability->TerminateAbility();
598 }
599 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
600 }
601 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_002 TerminateAbility";
602 }
603
604 /**
605 * @tc.number: AaFwk_Ability_Terminate_test_0300
606 * @tc.name: TerminateAbility
607 * @tc.desc: When the ability state is BACKGROUND, the call to terminateability terminates.
608 */
609 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0300, Function | MediumTest | Level1)
610 {
611 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
612 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
613 EXPECT_NE(abilityToken, nullptr);
614 if (abilityToken != nullptr) {
615 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
616 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
617 abilityInfo->name = ABILITY_NAME;
618 abilityInfo->isNativeAbility = true;
619 std::shared_ptr<AbilityLocalRecord> abilityRecord =
620 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
621
622 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0300 AbilityThreadMain";
623 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
624
625 Want want;
626 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
627 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
628 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
629
630 auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
631 EXPECT_NE(ability, nullptr);
632 if (ability != nullptr) {
633 ability->SetResult(RESULT_CODE, want);
634 ability->TerminateAbility();
635 }
636 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
637 }
638 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0300 TerminateAbility";
639 }
640
641 /**
642 * @tc.number: AaFwk_Ability_Terminate_test_0400
643 * @tc.name: TerminateAbility
644 * @tc.desc: When the ability state is ABILITY_STATE_INITIAL, the call to terminateability terminates.
645 */
646 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0400, Function | MediumTest | Level1)
647 {
648 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
649 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
650 EXPECT_NE(abilityToken, nullptr);
651 if (abilityToken != nullptr) {
652 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
653 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
654 abilityInfo->name = ABILITY_NAME;
655 abilityInfo->isNativeAbility = true;
656 std::shared_ptr<AbilityLocalRecord> abilityRecord =
657 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
658
659 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0400 AbilityThreadMain";
660 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
661
662 Want want;
663 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
664 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
665 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
666
667 auto ability = AbilityLoader::GetInstance().GetAbilityByName(abilityInfo->name);
668 EXPECT_NE(ability, nullptr);
669 if (ability != nullptr) {
670 ability->SetResult(RESULT_CODE, want);
671 ability->TerminateAbility();
672 }
673 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
674 }
675 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_0400 TerminateAbility";
676 }
677
678 /**
679 * @tc.number: AaFwk_Ability_Terminate_test_0500
680 * @tc.name: TerminateAbility
681 * @tc.desc: When the ability state is inactive, the call to terminateability terminates.
682 */
683 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0500, Function | MediumTest | Level1)
684 {
685 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
686 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
687 EXPECT_NE(abilityToken, nullptr);
688 if (abilityToken != nullptr) {
689 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
690 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
691 abilityInfo->name = ABILITY_NAME;
692 abilityInfo->isNativeAbility = true;
693 std::shared_ptr<AbilityLocalRecord> abilityRecord =
694 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
695
696 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_005 AbilityThreadMain";
697 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
698
699 Want want;
700 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
701 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
702 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
703
704 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
705 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
706 }
707 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_005 TerminateAbility";
708 }
709
710 /**
711 * @tc.number: AaFwk_Ability_Terminate_test_0600
712 * @tc.name: TerminateAbility
713 * @tc.desc: When the ability state is active, the call to terminateability terminates.
714 */
715 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0600, Function | MediumTest | Level1)
716 {
717 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
718 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
719 EXPECT_NE(abilityToken, nullptr);
720 if (abilityToken != nullptr) {
721 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
722 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
723 abilityInfo->name = ABILITY_NAME;
724 abilityInfo->isNativeAbility = true;
725 std::shared_ptr<AbilityLocalRecord> abilityRecord =
726 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
727
728 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_006 AbilityThreadMain";
729 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
730
731 Want want;
732 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
733 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
734 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
735
736 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
737 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
738 }
739 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_006 TerminateAbility";
740 }
741
742 /**
743 * @tc.number: AaFwk_Ability_Terminate_test_0700
744 * @tc.name: TerminateAbility
745 * @tc.desc: When the ability state is background, the call to terminateability terminates.
746 */
747 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0700, Function | MediumTest | Level1)
748 {
749 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
750 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
751 EXPECT_NE(abilityToken, nullptr);
752 if (abilityToken != nullptr) {
753 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
754 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
755 abilityInfo->name = ABILITY_NAME;
756 abilityInfo->isNativeAbility = true;
757 std::shared_ptr<AbilityLocalRecord> abilityRecord =
758 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
759
760 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_007 AbilityThreadMain";
761 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
762
763 Want want;
764 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
765 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
766 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
767
768 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
769 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
770 }
771 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_007 TerminateAbility";
772 }
773
774 /**
775 * @tc.number: AaFwk_Ability_Terminate_test_0800
776 * @tc.name: TerminateAbility
777 * @tc.desc: When the ability state is initial, the call to terminateability terminates.
778 */
779 HWTEST_F(AbilityTerminateTest, AaFwk_Ability_Terminate_test_0800, Function | MediumTest | Level1)
780 {
781 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
782 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
783 EXPECT_NE(abilityToken, nullptr);
784 if (abilityToken != nullptr) {
785 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
786 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
787 abilityInfo->name = ABILITY_NAME;
788 abilityInfo->isNativeAbility = true;
789 std::shared_ptr<AbilityLocalRecord> abilityRecord =
790 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
791
792 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_008 AbilityThreadMain";
793 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
794
795 Want want;
796 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
797 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
798 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
799
800 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
801 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
802 }
803 GTEST_LOG_(INFO) << "AaFwk_Ability_Terminate_test_008 TerminateAbility";
804 }
805
806 /**
807 * @tc.number: AaFwk_WMS_window_test_0100
808 * @tc.name: WMS Link
809 * @tc.desc: Start pageability and call GetWindow to get the window handle.
810 */
811 HWTEST_F(AbilityTerminateTest, AaFwk_WMS_window_test_0100, Function | MediumTest | Level1)
812 {
813 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
814 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
815 EXPECT_NE(abilityToken, nullptr);
816 if (abilityToken != nullptr) {
817 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
818 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
819 abilityInfo->name = ABILITY_NAME;
820 abilityInfo->isNativeAbility = true;
821 std::shared_ptr<AbilityLocalRecord> abilityRecord =
822 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
823
824 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 AbilityThreadMain";
825 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
826
827 Want want;
828 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
829 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 StartAbility";
830 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
831 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
832 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
833 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
834 }
835 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_001 TerminateAbility";
836 }
837
838 /**
839 * @tc.number: AaFwk_WMS_window_test_0200
840 * @tc.name: WMS Link
841 * @tc.desc: Pageability switches to the foreground and calls Window.show.
842 * Pageability switches to the background and calls Window.hide.
843 */
844 HWTEST_F(AbilityTerminateTest, AaFwk_WMS_window_test_0200, Function | MediumTest | Level1)
845 {
846 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
847 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
848 EXPECT_NE(abilityToken, nullptr);
849 if (abilityToken != nullptr) {
850 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
851 abilityInfo->type = AppExecFwk::AbilityType::PAGE;
852 abilityInfo->name = ABILITY_NAME;
853 abilityInfo->isNativeAbility = true;
854 std::shared_ptr<AbilityLocalRecord> abilityRecord =
855 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
856
857 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 AbilityThreadMain";
858 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
859
860 Want want;
861 MockAbilityManagerService* mockAMS = iface_cast<MockAbilityManagerService>(abilityObject_);
862 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
863 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 BackGround";
864 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
865 mockAMS->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
866 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 Active";
867 usleep(AbilityTerminateTest::TEST_WAIT_TIME);
868
869 mockAMS->TerminateAbility(nullptr, RESULT_CODE, &want);
870 }
871 GTEST_LOG_(INFO) << "AaFwk_WMS_window_test_002 TerminateAbility";
872 }
873
874 /**
875 * @tc.number: AaFwk_DataAbility_Launch_0100
876 * @tc.name: DataAbilityHelper
877 * @tc.desc: The AbilityManager could receive the shelder of abilitythread for dataability when the dataability
878 * launched.
879 */
880 HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Launch_0100, Function | MediumTest | Level1)
881 {
882 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Launch_0100";
883
884 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
885 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
886 EXPECT_NE(abilityToken, nullptr);
887 if (abilityToken != nullptr) {
888 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
889 abilityInfo->type = AppExecFwk::AbilityType::DATA;
890 abilityInfo->name = "DemoAbility";
891 std::shared_ptr<AbilityLocalRecord> abilityRecord =
892 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
893
894 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
895
896 sptr<IRemoteObject> remoteObject_ =
897 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
898 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
899
900 Uri uri("testuri");
901 EXPECT_TRUE(abms->AcquireDataAbility(uri, false, nullptr) == nullptr);
902 }
903 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Launch_0100";
904 }
905
906 /**
907 * @tc.number: AaFwk_DataAbility_Start_0100
908 * @tc.name: DataAbilityHelper
909 * @tc.desc: The AbilityManager could receive the inactive state from abilitythread for dataability when the
910 dataability
911 * change its lifecycle state to inactive.
912 */
913 HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0100, Function | MediumTest | Level1)
914 {
915 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0100";
916
917 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
918 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
919 EXPECT_NE(abilityToken, nullptr);
920 if (abilityToken != nullptr) {
921 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
922 abilityInfo->type = AppExecFwk::AbilityType::DATA;
923 abilityInfo->name = "DemoAbility";
924 std::shared_ptr<AbilityLocalRecord> abilityRecord =
925 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
926
927 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
928
929 sptr<IRemoteObject> remoteObject_ =
930 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
931 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
932 Want want;
933 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INACTIVE);
934
935 usleep(AbilityBaseTest::TEST_WAIT_TIME);
936 }
937 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0100";
938 }
939
940 /**
941 * @tc.number: AaFwk_DataAbility_Start_0200
942 * @tc.name: DataAbilityHelper
943 * @tc.desc: The AbilityManager could not receive the initial state from abilitythread for dataability.
944 * And the OnStop coulde be called. When the dataability change its lifecycle state to initial.
945 */
946 HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0200, Function | MediumTest | Level1)
947 {
948 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0200";
949
950 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
951 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
952 EXPECT_NE(abilityToken, nullptr);
953 if (abilityToken != nullptr) {
954 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
955 abilityInfo->type = AppExecFwk::AbilityType::DATA;
956 abilityInfo->name = "DemoAbility";
957 std::shared_ptr<AbilityLocalRecord> abilityRecord =
958 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
959
960 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
961
962 sptr<IRemoteObject> remoteObject_ =
963 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
964 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
965 Want want;
966 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_INITIAL);
967
968 usleep(AbilityBaseTest::TEST_WAIT_TIME);
969 }
970 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0200";
971 }
972
973 /**
974 * @tc.number: AaFwk_DataAbility_Start_0300
975 * @tc.name: DataAbilityHelper
976 * @tc.desc: The AbilityManager could not receive the active state from abilitythread for dataability.
977 * And the OnActive coulde be called. When the dataability change its lifecycle state to active.
978 */
979 HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0300, Function | MediumTest | Level1)
980 {
981 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0300";
982
983 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
984 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
985 EXPECT_NE(abilityToken, nullptr);
986 if (abilityToken != nullptr) {
987 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
988 abilityInfo->type = AppExecFwk::AbilityType::DATA;
989 abilityInfo->name = "DemoAbility";
990 std::shared_ptr<AbilityLocalRecord> abilityRecord =
991 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
992
993 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
994
995 sptr<IRemoteObject> remoteObject_ =
996 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
997 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
998 Want want;
999 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_ACTIVE);
1000
1001 usleep(AbilityBaseTest::TEST_WAIT_TIME);
1002 }
1003 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0300";
1004 }
1005
1006 /**
1007 * @tc.number: AaFwk_DataAbility_Start_0400
1008 * @tc.name: DataAbilityHelper
1009 * @tc.desc: The AbilityManager could not receive the background state from abilitythread for dataability.
1010 * And the OnBackground coulde be called. When the dataability change its lifecycle state to background.
1011 */
1012 HWTEST_F(AbilityTerminateTest, AaFwk_DataAbility_Start_0400, Function | MediumTest | Level1)
1013 {
1014 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0400";
1015
1016 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
1017 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
1018 EXPECT_NE(abilityToken, nullptr);
1019 if (abilityToken != nullptr) {
1020 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
1021 abilityInfo->type = AppExecFwk::AbilityType::DATA;
1022 abilityInfo->name = "DemoAbility";
1023 std::shared_ptr<AbilityLocalRecord> abilityRecord =
1024 std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
1025
1026 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
1027
1028 sptr<IRemoteObject> remoteObject_ =
1029 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1030 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1031 Want want;
1032 abms->StartAbility(want, AbilityLifeCycleState::ABILITY_STATE_BACKGROUND);
1033
1034 usleep(AbilityBaseTest::TEST_WAIT_TIME);
1035 }
1036 GTEST_LOG_(INFO) << "AaFwk_DataAbility_Start_0400";
1037 }
1038
1039 /**
1040 * @tc.number: AaFwk_IAbilityManager_StartAbilityAsCaller_0100
1041 * @tc.name: StartAbilityAsCaller
1042 * @tc.desc: test StartAbilityAsCaller function
1043 */
1044 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartAbilityAsCaller_0100, Function | MediumTest | Level1)
1045 {
1046 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0100";
1047 sptr<IRemoteObject> remoteObject_ =
1048 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1049 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1050 EXPECT_NE(abms, nullptr);
1051 Want want;
1052 EXPECT_EQ(0, abms->StartAbilityAsCaller(want, nullptr));
1053 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0100";
1054 }
1055
1056 /**
1057 * @tc.number: AaFwk_IAbilityManager_StartAbilityAsCaller_0200
1058 * @tc.name: StartAbilityAsCaller
1059 * @tc.desc: test StartAbilityAsCaller function
1060 */
1061 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartAbilityAsCaller_0200, Function | MediumTest | Level1)
1062 {
1063 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0200";
1064 sptr<IRemoteObject> remoteObject_ =
1065 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1066 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1067 EXPECT_NE(abms, nullptr);
1068 Want want;
1069 StartOptions startOptions;
1070 EXPECT_EQ(0, abms->StartAbilityAsCaller(want, startOptions, nullptr));
1071 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartAbilityAsCaller_0200";
1072 }
1073
1074 /**
1075 * @tc.number: AaFwk_IAbilityManager_StartUIExtensionAbility_0100
1076 * @tc.name: StartUIExtensionAbility
1077 * @tc.desc: test StartUIExtensionAbility function
1078 */
1079 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_StartUIExtensionAbility_0100, Function | MediumTest | Level1)
1080 {
1081 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartUIExtensionAbility_0100";
1082 sptr<IRemoteObject> remoteObject_ =
1083 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1084 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1085 EXPECT_NE(abms, nullptr);
1086 Want want;
1087 EXPECT_EQ(0, abms->StartAbilityAsCaller(want, nullptr));
1088 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_StartUIExtensionAbility_0100";
1089 }
1090
1091 /**
1092 * @tc.number: AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100
1093 * @tc.name: TerminateUIExtensionAbility
1094 * @tc.desc: test TerminateUIExtensionAbility function
1095 */
1096 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100, Function | MediumTest | Level1)
1097 {
1098 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100";
1099 sptr<IRemoteObject> remoteObject_ =
1100 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1101 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1102 EXPECT_NE(abms, nullptr);
1103 int resultCode = 1;
1104 EXPECT_EQ(0, abms->TerminateUIExtensionAbility(nullptr, resultCode));
1105 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_TerminateUIExtensionAbility_0100";
1106 }
1107
1108 /**
1109 * @tc.number: AaFwk_IAbilityManager_SendResultToAbility_0100
1110 * @tc.name: SendResultToAbility
1111 * @tc.desc: test SendResultToAbility function
1112 */
1113 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_SendResultToAbility_0100, Function | MediumTest | Level1)
1114 {
1115 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbility_0100";
1116 sptr<IRemoteObject> remoteObject_ =
1117 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1118 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1119 EXPECT_NE(abms, nullptr);
1120 int requestCode = 1;
1121 int resultCode = 2;
1122 Want resultWant;
1123 EXPECT_EQ(0, abms->SendResultToAbility(requestCode, resultCode, resultWant));
1124 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbility_0100";
1125 }
1126
1127 /**
1128 * @tc.number: AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100
1129 * @tc.name: MinimizeUIExtensionAbility
1130 * @tc.desc: test MinimizeUIExtensionAbility function
1131 */
1132 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100, Function | MediumTest | Level1)
1133 {
1134 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100";
1135 sptr<IRemoteObject> remoteObject_ =
1136 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1137 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1138 EXPECT_NE(abms, nullptr);
1139 EXPECT_EQ(0, abms->MinimizeUIExtensionAbility(nullptr));
1140 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_MinimizeUIExtensionAbility_0100";
1141 }
1142
1143 /**
1144 * @tc.number: AaFwk_IAbilityManager_CallRequestDone_0100
1145 * @tc.name: CallRequestDone
1146 * @tc.desc: test CallRequestDone function
1147 */
1148 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_CallRequestDone_0100, Function | MediumTest | Level1)
1149 {
1150 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_CallRequestDone_0100";
1151 sptr<IRemoteObject> remoteObject_ =
1152 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1153 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1154 EXPECT_NE(abms, nullptr);
1155 abms->CallRequestDone(nullptr, nullptr);
1156 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_CallRequestDone_0100";
1157 }
1158
1159 /**
1160 * @tc.number: AaFwk_IAbilityManager_SetComponentInterception_0100
1161 * @tc.name: SetComponentInterception
1162 * @tc.desc: test SetComponentInterception function
1163 */
1164 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_SetComponentInterception_0100, Function | MediumTest | Level1)
1165 {
1166 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SetComponentInterception_0100";
1167 sptr<IRemoteObject> remoteObject_ =
1168 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1169 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1170 EXPECT_NE(abms, nullptr);
1171 EXPECT_EQ(0, abms->SetComponentInterception(nullptr));
1172 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SetComponentInterception_0100";
1173 }
1174
1175 /**
1176 * @tc.number: AaFwk_IAbilityManager_SendResultToAbilityByToken_0100
1177 * @tc.name: SendResultToAbilityByToken
1178 * @tc.desc: test SendResultToAbilityByToken function
1179 */
1180 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_SendResultToAbilityByToken_0100, Function | MediumTest | Level1)
1181 {
1182 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbilityByToken_0100";
1183 sptr<IRemoteObject> remoteObject_ =
1184 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1185 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1186 EXPECT_NE(abms, nullptr);
1187 Want want;
1188 int32_t requestCode = 1;
1189 int32_t resultCode = 1;
1190 int32_t userId = 1;
1191 EXPECT_EQ(0, abms->SendResultToAbilityByToken(want, nullptr, requestCode, resultCode, userId));
1192 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_SendResultToAbilityByToken_0100";
1193 }
1194
1195 /**
1196 * @tc.number: AaFwk_IAbilityManager_AddFreeInstallObserver_0100
1197 * @tc.name: AddFreeInstallObserver
1198 * @tc.desc: test AddFreeInstallObserver function
1199 */
1200 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_AddFreeInstallObserver_0100, Function | MediumTest | Level1)
1201 {
1202 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_AddFreeInstallObserver_0100";
1203 sptr<IRemoteObject> remoteObject_ =
1204 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1205 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1206 EXPECT_NE(abms, nullptr);
1207 EXPECT_EQ(0, abms->AddFreeInstallObserver(nullptr));
1208 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_AddFreeInstallObserver_0100";
1209 }
1210
1211 /**
1212 * @tc.number: AaFwk_IAbilityManager_EnableRecoverAbility_0100
1213 * @tc.name: EnableRecoverAbility
1214 * @tc.desc: test EnableRecoverAbility function
1215 */
1216 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_EnableRecoverAbility_0100, Function | MediumTest | Level1)
1217 {
1218 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_EnableRecoverAbility_0100";
1219 sptr<IRemoteObject> remoteObject_ =
1220 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1221 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1222 EXPECT_NE(abms, nullptr);
1223 abms->EnableRecoverAbility(nullptr);
1224 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_EnableRecoverAbility_0100";
1225 }
1226
1227 /**
1228 * @tc.number: AaFwk_IAbilityManager_ScheduleRecoverAbility_0100
1229 * @tc.name: ScheduleRecoverAbility
1230 * @tc.desc: test ScheduleRecoverAbility function
1231 */
1232 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_ScheduleRecoverAbility_0100, Function | MediumTest | Level1)
1233 {
1234 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_ScheduleRecoverAbility_0100";
1235 sptr<IRemoteObject> remoteObject_ =
1236 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1237 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1238 EXPECT_NE(abms, nullptr);
1239 int32_t reason = 1;
1240 abms->ScheduleRecoverAbility(nullptr, reason);
1241 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_ScheduleRecoverAbility_0100";
1242 }
1243
1244 /**
1245 * @tc.number: AaFwk_IAbilityManager_VerifyPermission_0100
1246 * @tc.name: VerifyPermission
1247 * @tc.desc: test VerifyPermission function
1248 */
1249 HWTEST_F(AbilityTerminateTest, AaFwk_IAbilityManager_VerifyPermission_0100, Function | MediumTest | Level1)
1250 {
1251 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_VerifyPermission_0100";
1252 sptr<IRemoteObject> remoteObject_ =
1253 OHOS::DelayedSingleton<AppExecFwk::SysMrgClient>::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
1254 sptr<AAFwk::IAbilityManager> abms = iface_cast<AAFwk::IAbilityManager>(remoteObject_);
1255 EXPECT_NE(abms, nullptr);
1256 std::string permission = "<permission>";
1257 int pid = 1;
1258 int uid = 1;
1259 EXPECT_EQ(0, abms->VerifyPermission(permission, pid, uid));
1260 GTEST_LOG_(INFO) << "AaFwk_IAbilityManager_VerifyPermission_0100";
1261 }
1262
1263 #ifndef SUPPORT_ERMS
1264 /**
1265 * @tc.number: AppExecFwk_IEcologicalRuleManager_QueryFreeInstallExperience_0100
1266 * @tc.name: QueryFreeInstallExperience
1267 * @tc.desc: test QueryFreeInstallExperience function
1268 */
1269 HWTEST_F(AbilityTerminateTest,
1270 AppExecFwk_IEcologicalRuleManager_QueryFreeInstallExperience_0100, Function | MediumTest | Level1)
1271 {
1272 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryFreeInstallExperience_0100";
1273 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1274 EXPECT_NE(erms, nullptr);
1275 Want want;
1276 ErmsParams::CallerInfo callerInfo;
1277 ErmsParams::ExperienceRule rule;
1278 EXPECT_EQ(0, erms->QueryFreeInstallExperience(want, callerInfo, rule));
1279 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryFreeInstallExperience_0100";
1280 }
1281
1282 /**
1283 * @tc.number: AppExecFwk_IEcologicalRuleManager_EvaluateResolveInfos_0100
1284 * @tc.name: EvaluateResolveInfos
1285 * @tc.desc: test EvaluateResolveInfos function
1286 */
1287 HWTEST_F(AbilityTerminateTest,
1288 AppExecFwk_IEcologicalRuleManager_EvaluateResolveInfos_0100, Function | MediumTest | Level1)
1289 {
1290 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_EvaluateResolveInfos_0100";
1291 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1292 EXPECT_NE(erms, nullptr);
1293 Want want;
1294 ErmsParams::CallerInfo callerInfo;
1295 int32_t type = 1;
1296 std::vector<AbilityInfo> abilityInfos;
1297 std::vector<ExtensionAbilityInfo> extensionInfos;
1298 EXPECT_EQ(0, erms->EvaluateResolveInfos(want, callerInfo, type, abilityInfos, extensionInfos));
1299 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_EvaluateResolveInfos_0100";
1300 }
1301
1302 /**
1303 * @tc.number: AppExecFwk_IEcologicalRuleManager_QueryStartExperience_0100
1304 * @tc.name: QueryStartExperience
1305 * @tc.desc: test QueryStartExperience function
1306 */
1307 HWTEST_F(AbilityTerminateTest,
1308 AppExecFwk_IEcologicalRuleManager_QueryStartExperience_0100, Function | MediumTest | Level1)
1309 {
1310 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryStartExperience_0100";
1311 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1312 EXPECT_NE(erms, nullptr);
1313 Want want;
1314 ErmsParams::CallerInfo callerInfo;
1315 ErmsParams::ExperienceRule rule;
1316 EXPECT_EQ(0, erms->QueryStartExperience(want, callerInfo, rule));
1317 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryStartExperience_0100";
1318 }
1319
1320 /**
1321 * @tc.number: AppExecFwk_IEcologicalRuleManager_QueryPublishFormExperience_0100
1322 * @tc.name: QueryPublishFormExperience
1323 * @tc.desc: test QueryPublishFormExperience function
1324 */
1325 HWTEST_F(AbilityTerminateTest,
1326 AppExecFwk_IEcologicalRuleManager_QueryPublishFormExperience_0100, Function | MediumTest | Level1)
1327 {
1328 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryPublishFormExperience_0100";
1329 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1330 EXPECT_NE(erms, nullptr);
1331 Want want;
1332 ErmsParams::ExperienceRule rule;
1333 EXPECT_EQ(0, erms->QueryPublishFormExperience(want, rule));
1334 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryPublishFormExperience_0100";
1335 }
1336
1337 /**
1338 * @tc.number: AppExecFwk_IEcologicalRuleManager_IsSupportPublishForm_0100
1339 * @tc.name: IsSupportPublishForm
1340 * @tc.desc: test IsSupportPublishForm function
1341 */
1342 HWTEST_F(AbilityTerminateTest,
1343 AppExecFwk_IEcologicalRuleManager_IsSupportPublishForm_0100, Function | MediumTest | Level1)
1344 {
1345 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_IsSupportPublishForm_0100";
1346 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1347 EXPECT_NE(erms, nullptr);
1348 Want want;
1349 ErmsParams::CallerInfo callerInfo;
1350 ErmsParams::ExperienceRule rule;
1351 EXPECT_EQ(0, erms->IsSupportPublishForm(want, callerInfo, rule));
1352 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_IsSupportPublishForm_0100";
1353 }
1354
1355 /**
1356 * @tc.number: AppExecFwk_IEcologicalRuleManager_QueryLastSyncTime_0100
1357 * @tc.name: QueryLastSyncTime
1358 * @tc.desc: test QueryLastSyncTime function
1359 */
1360 HWTEST_F(AbilityTerminateTest,
1361 AppExecFwk_IEcologicalRuleManager_QueryLastSyncTime_0100, Function | MediumTest | Level1)
1362 {
1363 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryLastSyncTime_0100";
1364 sptr<AppExecFwk::IEcologicalRuleManager> erms = new (std::nothrow) TestIEcologicalRuleManager();
1365 EXPECT_NE(erms, nullptr);
1366 EXPECT_EQ(0, erms->QueryLastSyncTime());
1367 GTEST_LOG_(INFO) << "AppExecFwk_IEcologicalRuleManager_QueryLastSyncTime_0100";
1368 }
1369 #endif
1370 } // namespace AppExecFwk
1371 } // namespace OHOS
1372