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