1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "ability_event_handler.h"
20 #include "ability_manager_service.h"
21 #undef private
22 #undef protected
23
24 #include "ability_manager_errors.h"
25 #include "if_system_ability_manager.h"
26 #include "iservice_registry.h"
27 #include "mock_ability_connect_callback.h"
28 #include "mock_bundle_mgr.h"
29 #include "sa_mgr_client.h"
30 #include "system_ability_definition.h"
31 #include "ui_service_mgr_client_mock.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::AppExecFwk;
36 namespace {
37 const std::string EVENT_MULT_APP_CHOOSE = "EVENT_MULT_APP_CHOOSE";
38 const std::string EVENT_MULT_APP_CLOSE = "EVENT_MULT_APP_CLOSE";
39 const std::string EVENT_TIPS_APP = "EVENT_TIPS_APP";
40 const std::string ACTION_VIEW = "ohos.want.action.viewData";
41 const std::string WANT_TYPE = "image/png";
42 const int32_t MOCK_MAIN_USER_ID = 100;
43 }
44 namespace OHOS {
45 namespace AAFwk {
WaitUntilTaskFinished()46 static void WaitUntilTaskFinished()
47 {
48 const uint32_t maxRetryCount = 1000;
49 const uint32_t sleepTime = 1000;
50 uint32_t count = 0;
51 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
52 std::atomic<bool> taskCalled(false);
53 auto f = [&taskCalled]() { taskCalled.store(true); };
54 if (handler->PostTask(f)) {
55 while (!taskCalled.load()) {
56 ++count;
57 if (count >= maxRetryCount) {
58 break;
59 }
60 usleep(sleepTime);
61 }
62 }
63 }
64
65 class StartAbilityImplicitModuleTest : public testing::Test {
66 public:
67 static void TearDownTestCase();
68 void SetUp();
69 void TearDown();
70 void OnStartAms() const;
71 void OnStopAms() const;
72 static constexpr int TEST_WAIT_TIME = 100000;
73
74 public:
75 AbilityRequest abilityRequest_;
76 std::shared_ptr<AbilityRecord> abilityRecord_ {nullptr};
77 std::shared_ptr<AbilityManagerService> abilityMs_ = DelayedSingleton<AbilityManagerService>::GetInstance();
78 };
79
OnStartAms() const80 void StartAbilityImplicitModuleTest::OnStartAms() const
81 {
82 if (abilityMs_) {
83 if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) {
84 return;
85 }
86
87 abilityMs_->state_ = ServiceRunningState::STATE_RUNNING;
88 abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
89 EXPECT_TRUE(abilityMs_->eventLoop_);
90 abilityMs_->handler_ = std::make_shared<AbilityEventHandler>(abilityMs_->eventLoop_, abilityMs_);
91 // init user controller.
92 abilityMs_->userController_ = std::make_shared<UserController>();
93 EXPECT_TRUE(abilityMs_->userController_);
94 abilityMs_->userController_->Init();
95 int userId = MOCK_MAIN_USER_ID;
96 abilityMs_->InitConnectManager(userId, true);
97 abilityMs_->InitDataAbilityManager(userId, true);
98 abilityMs_->InitPendWantManager(userId, true);
99
100 abilityMs_->dataAbilityManager_ = std::make_shared<DataAbilityManager>();
101 abilityMs_->dataAbilityManagers_.emplace(0, abilityMs_->dataAbilityManager_);
102 EXPECT_TRUE(abilityMs_->dataAbilityManager_);
103 abilityMs_->amsConfigResolver_ = std::make_shared<AmsConfigurationParameter>();
104 EXPECT_TRUE(abilityMs_->amsConfigResolver_);
105 abilityMs_->amsConfigResolver_->Parse();
106 abilityMs_->pendingWantManager_ = std::make_shared<PendingWantManager>();
107 EXPECT_TRUE(abilityMs_->pendingWantManager_);
108 abilityMs_->iBundleManager_ = new BundleMgrService();
109 EXPECT_TRUE(abilityMs_->iBundleManager_);
110
111 abilityMs_->implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
112 EXPECT_TRUE(abilityMs_->implicitStartProcessor_);
113 abilityMs_->implicitStartProcessor_->iBundleManager_ = new BundleMgrService();
114 EXPECT_TRUE(abilityMs_->implicitStartProcessor_->iBundleManager_);
115
116 DelayedSingleton<SystemDialogScheduler>::GetInstance()->SetDeviceType("phone");
117 abilityMs_->InitMissionListManager(userId, true);
118 abilityMs_->SwitchManagers(0, false);
119 abilityMs_->userController_->SetCurrentUserId(MOCK_MAIN_USER_ID);
120 abilityMs_->eventLoop_->Run();
121 return;
122 }
123
124 GTEST_LOG_(INFO) << "OnStart fail";
125 }
126
OnStopAms() const127 void StartAbilityImplicitModuleTest::OnStopAms() const
128 {
129 abilityMs_->currentMissionListManager_->launcherList_->missions_.clear();
130 abilityMs_->currentMissionListManager_->defaultStandardList_->missions_.clear();
131 abilityMs_->currentMissionListManager_->defaultSingleList_->missions_.clear();
132 abilityMs_->currentMissionListManager_->currentMissionLists_.clear();
133 abilityMs_->OnStop();
134 }
135
TearDownTestCase()136 void StartAbilityImplicitModuleTest::TearDownTestCase()
137 {
138 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
139 }
140
SetUp()141 void StartAbilityImplicitModuleTest::SetUp()
142 {
143 OnStartAms();
144 WaitUntilTaskFinished();
145 }
146
TearDown()147 void StartAbilityImplicitModuleTest::TearDown()
148 {
149 OnStopAms();
150 }
151
152 /*
153 * Feature: StartAbilityImplicitModuleTest
154 * Function: StartAbility
155 * SubFunction: NA
156 * FunctionPoints: start ability by action
157 * EnvConditions: NA
158 * CaseDescription: start ability by action and type successful
159 */
160 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_001, TestSize.Level1)
161 {
162 EXPECT_TRUE(abilityMs_ != nullptr);
163
164 Want want;
165 want.SetAction(ACTION_VIEW);
166 want.SetType(WANT_TYPE);
167 want.SetParam("numMock", 3);
168
169 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
170 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
171 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
172 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
173
174 EXPECT_TRUE(!params.empty());
175 EXPECT_TRUE(isCallBack);
176
177 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
178 EXPECT_TRUE(abilityRecord != nullptr);
179
180 GTEST_LOG_(INFO) << "ability:" << abilityRecord->GetAbilityInfo().name;
181 GTEST_LOG_(INFO) << "bundle:" << abilityRecord->GetAbilityInfo().bundleName;
182 }
183
184 /*
185 * Feature: StartAbilityImplicitModuleTest
186 * Function: StartAbility
187 * SubFunction: NA
188 * FunctionPoints: start ability by action
189 * EnvConditions: NA
190 * CaseDescription: start ability by action and type successful
191 */
192 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_002, TestSize.Level1)
193 {
194 EXPECT_TRUE(abilityMs_ != nullptr);
195
196 Want want;
197 want.SetAction(ACTION_VIEW);
198 want.SetType(WANT_TYPE);
199 want.SetParam("numMock", 3);
200
201 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CLOSE);
202 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
203 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
204 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
205
206 EXPECT_TRUE(!params.empty());
207 EXPECT_TRUE(isCallBack);
208
209 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
210 EXPECT_TRUE(abilityRecord == nullptr);
211 }
212
213 /*
214 * Feature: StartAbilityImplicitModuleTest
215 * Function: StartAbility
216 * SubFunction: NA
217 * FunctionPoints: start ability by action
218 * EnvConditions: NA
219 * CaseDescription: start ability by action and type successful
220 */
221 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_003, TestSize.Level1)
222 {
223 EXPECT_TRUE(abilityMs_ != nullptr);
224
225 Want want;
226 want.SetAction(ACTION_VIEW);
227 want.SetType(WANT_TYPE);
228 want.SetParam("numMock", 1);
229
230 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
231 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
232 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
233 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
234
235 EXPECT_TRUE(params.empty());
236 EXPECT_TRUE(!isCallBack);
237
238 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
239 EXPECT_TRUE(abilityRecord != nullptr);
240 }
241
242 /*
243 * Feature: StartAbilityImplicitModuleTest
244 * Function: StartAbility
245 * SubFunction: NA
246 * FunctionPoints: start ability by action
247 * EnvConditions: NA
248 * CaseDescription: start ability by action and type successful
249 */
250 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_004, TestSize.Level1)
251 {
252 EXPECT_TRUE(abilityMs_ != nullptr);
253
254 Want want;
255 want.SetAction(ACTION_VIEW);
256 want.SetType(WANT_TYPE);
257 want.SetParam("numMock", 0);
258
259 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_TIPS_APP);
260 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
261 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
262 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
263
264 EXPECT_TRUE(!params.empty());
265 EXPECT_TRUE(isCallBack);
266
267 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
268 EXPECT_TRUE(abilityRecord == nullptr);
269 }
270
271 /*
272 * Feature: StartAbilityImplicitModuleTest
273 * Function: StartAbility
274 * SubFunction: NA
275 * FunctionPoints: start ability by action
276 * EnvConditions: NA
277 * CaseDescription: start ability by action and type successful
278 */
279 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_005, TestSize.Level1)
280 {
281 EXPECT_TRUE(abilityMs_ != nullptr);
282
283 Want want;
284 want.SetAction(ACTION_VIEW);
285 want.SetParam("numMock", 3);
286
287 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
288 auto ret = abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
289
290 EXPECT_EQ(ret, ERR_OK);
291 }
292 }
293 }