1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "ability_thread.h"
18 #include "ability_context.h"
19 #include "ability_loader.h"
20 #include "ability_manager_client.h"
21 #include "context_deal.h"
22 #include "mock_serviceability_manager_service.h"
23 #include "ohos_application.h"
24 #include "system_ability_definition.h"
25 #include "sys_mgr_client.h"
26
27 namespace OHOS {
28 namespace AppExecFwk {
29 using namespace testing::ext;
30 using namespace OHOS::AppExecFwk;
31 using namespace OHOS;
32 using namespace AAFwk;
33
34 namespace {
35 const std::string ACE_SERVICE_ABILITY_NAME = "AceServiceAbility";
36 }
37 class AbilityContextTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 static constexpr int TEST_WAIT_TIME = 500 * 1000; // 500 ms
44 public:
45 std::unique_ptr<AbilityContext> context_ = nullptr;
46 };
47
SetUpTestCase(void)48 void AbilityContextTest::SetUpTestCase(void)
49 {
50 OHOS::sptr<OHOS::IRemoteObject> abilityObject = new (std::nothrow) MockServiceAbilityManagerService();
51
52 auto sysMgr = OHOS::DelayedSingleton<SysMrgClient>::GetInstance();
53 if (sysMgr == nullptr) {
54 GTEST_LOG_(ERROR) << "fail to get ISystemAbilityManager";
55 return;
56 }
57
58 sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject);
59
60 AbilityLoader::GetInstance().RegisterAbility(
61 ACE_SERVICE_ABILITY_NAME, []()->Ability *{ return new (std::nothrow) Ability; });
62 }
63
TearDownTestCase(void)64 void AbilityContextTest::TearDownTestCase(void)
65 {}
66
SetUp(void)67 void AbilityContextTest::SetUp(void)
68 {
69 context_ = std::make_unique<AbilityContext>();
70 }
71
TearDown(void)72 void AbilityContextTest::TearDown(void)
73 {}
74
75 /**
76 * @tc.number: AaFwk_Ability_Context_ConnectAbility_0100
77 * @tc.name: AbilityFwk
78 * @tc.desc: When connecting ability, AMS will inform ability to process OnStart in the life cycle, and then inform
79 * ability to process onconnect, and the connection is successful
80 */
81 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_ConnectAbility_0100, Function | MediumTest | Level1)
82 {
83 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
84 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
85 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
86 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
87 abilityInfo->name = "DemoAbility";
88 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
89
90 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
91
92 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
93 deal->SetAbilityInfo(abilityInfo);
94 context_->AttachBaseContext(deal);
95
96 Want want;
97 bool ret = context_->ConnectAbility(want, nullptr);
98 EXPECT_TRUE(ret);
99 usleep(AbilityContextTest::TEST_WAIT_TIME);
100 }
101
102 /**
103 * @tc.number: AaFwk_Ability_Context_DisconnectAbility_0100
104 * @tc.name: AbilityFwk
105 * @tc.desc: AMS notifies the abilityondisconnect event when disconnectservice.
106 */
107 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_DisconnectAbility_0100, Function | MediumTest | Level1)
108 {
109 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
110 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
111 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
112 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
113 abilityInfo->name = "DemoAbility";
114 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
115
116 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
117
118 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
119 deal->SetAbilityInfo(abilityInfo);
120 context_->AttachBaseContext(deal);
121
122 Want want;
123 context_->ConnectAbility(want, nullptr);
124 context_->DisconnectAbility(nullptr);
125 usleep(AbilityContextTest::TEST_WAIT_TIME);
126 }
127
128 /**
129 * @tc.number: AaFwk_Ability_Context_StartAbility_0100
130 * @tc.name: AbilityFwk
131 * @tc.desc: Starting ability service, AMS will inform ability to perform OnStart lifecycle conversion, and then inform
132 * oncommand event.
133 */
134 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_StartAbility_0100, Function | MediumTest | Level1)
135 {
136 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
137 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
138 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
139 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
140 abilityInfo->name = "DemoAbility";
141 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
142
143 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
144 Want want;
145 context_->StartAbility(want, -1);
146 usleep(AbilityContextTest::TEST_WAIT_TIME);
147 }
148
149 /**
150 * @tc.number: AaFwk_Ability_Context_TerminateAbility_0100
151 * @tc.name: AbilityFwk
152 * @tc.desc: To terminate ability service, AMS will notify ability to perform onbackground lifecycle conversion, and
153 * then notify onstop event.
154 */
155 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_TerminateAbility_0100, Function | MediumTest | Level1)
156 {
157 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
158 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
159 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
160 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
161 abilityInfo->name = "DemoAbility";
162 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
163
164 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
165 Want want;
166 context_->StartAbility(want, -1);
167 usleep(AbilityContextTest::TEST_WAIT_TIME);
168
169 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
170 deal->SetAbilityInfo(abilityInfo);
171 context_->AttachBaseContext(deal);
172 context_->TerminateAbility();
173 usleep(AbilityContextTest::TEST_WAIT_TIME);
174 }
175
176 /**
177 * @tc.number: AaFwk_Ability_Context_TerminateAbility_0200
178 * @tc.name: AbilityFwk
179 * @tc.desc: When there is no startability, calling terminateability directly will not respond to onbackground and
180 * onstop events.
181 */
182 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_TerminateAbility_0200, Function | MediumTest | Level1)
183 {
184 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
185 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
186 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
187 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
188 abilityInfo->name = "DemoAbility";
189 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
190
191 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
192
193 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
194 deal->SetAbilityInfo(abilityInfo);
195 context_->AttachBaseContext(deal);
196 context_->TerminateAbility();
197 usleep(AbilityContextTest::TEST_WAIT_TIME);
198 }
199
200 /**
201 * @tc.number: AaFwk_Ability_Context_StopService_0100
202 * @tc.name: AbilityFwk
203 * @tc.desc: To stop ability service, AMS will notify ability to perform onbackground lifecycle conversion, and then
204 * notify onstop event.
205 */
206 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_StopService_0100, Function | MediumTest | Level1)
207 {
208 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
209 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
210 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
211 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
212 abilityInfo->name = "DemoAbility";
213 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
214
215 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
216
217 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
218 deal->SetAbilityInfo(abilityInfo);
219 context_->AttachBaseContext(deal);
220
221 Want want;
222 context_->StartAbility(want, -1);
223 usleep(AbilityContextTest::TEST_WAIT_TIME);
224 bool ret = context_->StopAbility(want);
225 EXPECT_TRUE(ret);
226 usleep(AbilityContextTest::TEST_WAIT_TIME);
227 }
228
229 /**
230 * @tc.number: AaFwk_Ability_Context_StopService_0200
231 * @tc.name: AbilityFwk
232 * @tc.desc: When there is no startability, calling stop ability directly will not respond to onbackground and onstop
233 * events.
234 */
235 HWTEST_F(AbilityContextTest, AaFwk_Ability_Context_StopService_0200, Function | MediumTest | Level1)
236 {
237 std::shared_ptr<OHOSApplication> application = std::make_shared<OHOSApplication>();
238 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new AbilityThread());
239 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
240 abilityInfo->type = AppExecFwk::AbilityType::SERVICE;
241 abilityInfo->name = "DemoAbility";
242 std::shared_ptr<AbilityLocalRecord> abilityRecord = std::make_shared<AbilityLocalRecord>(abilityInfo, abilityToken);
243
244 AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr);
245 std::shared_ptr<ContextDeal> deal = std::make_shared<ContextDeal>();
246 deal->SetAbilityInfo(abilityInfo);
247 context_->AttachBaseContext(deal);
248
249 Want want;
250 bool ret = context_->StopAbility(want);
251 EXPECT_TRUE(ret);
252 usleep(AbilityContextTest::TEST_WAIT_TIME);
253 }
254 } // namespace AppExecFwk
255 } // namespace OHOS
256