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()->GetTaskHandler();
52 std::atomic<bool> taskCalled(false);
53 auto f = [&taskCalled]() { taskCalled.store(true); };
54 if (handler->SubmitTask(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_->taskHandler_ = TaskHandlerWrap::CreateQueueHandler("StartAbilityImplicitModuleTest");
89 // init user controller.
90 abilityMs_->userController_ = std::make_shared<UserController>();
91 EXPECT_TRUE(abilityMs_->userController_);
92 abilityMs_->userController_->Init();
93 int userId = MOCK_MAIN_USER_ID;
94 abilityMs_->InitConnectManager(userId, true);
95 abilityMs_->InitDataAbilityManager(userId, true);
96 abilityMs_->InitPendWantManager(userId, true);
97
98 abilityMs_->dataAbilityManager_ = std::make_shared<DataAbilityManager>();
99 abilityMs_->dataAbilityManagers_.emplace(0, abilityMs_->dataAbilityManager_);
100 EXPECT_TRUE(abilityMs_->dataAbilityManager_);
101 AmsConfigurationParameter::GetInstance().Parse();
102 abilityMs_->pendingWantManager_ = std::make_shared<PendingWantManager>();
103 EXPECT_TRUE(abilityMs_->pendingWantManager_);
104 abilityMs_->iBundleManager_ = new BundleMgrService();
105 EXPECT_TRUE(abilityMs_->iBundleManager_);
106
107 abilityMs_->implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
108 EXPECT_TRUE(abilityMs_->implicitStartProcessor_);
109 abilityMs_->implicitStartProcessor_->iBundleManager_ = new BundleMgrService();
110 EXPECT_TRUE(abilityMs_->implicitStartProcessor_->iBundleManager_);
111
112 DelayedSingleton<SystemDialogScheduler>::GetInstance()->SetDeviceType("phone");
113 abilityMs_->InitMissionListManager(userId, true);
114 abilityMs_->SwitchManagers(0, false);
115 abilityMs_->userController_->SetCurrentUserId(MOCK_MAIN_USER_ID);
116 return;
117 }
118
119 GTEST_LOG_(INFO) << "OnStart fail";
120 }
121
OnStopAms() const122 void StartAbilityImplicitModuleTest::OnStopAms() const
123 {
124 abilityMs_->currentMissionListManager_->launcherList_->missions_.clear();
125 abilityMs_->currentMissionListManager_->defaultStandardList_->missions_.clear();
126 abilityMs_->currentMissionListManager_->defaultSingleList_->missions_.clear();
127 abilityMs_->currentMissionListManager_->currentMissionLists_.clear();
128 abilityMs_->OnStop();
129 }
130
TearDownTestCase()131 void StartAbilityImplicitModuleTest::TearDownTestCase()
132 {
133 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
134 }
135
SetUp()136 void StartAbilityImplicitModuleTest::SetUp()
137 {
138 OnStartAms();
139 WaitUntilTaskFinished();
140 }
141
TearDown()142 void StartAbilityImplicitModuleTest::TearDown()
143 {
144 OnStopAms();
145 }
146
147 /*
148 * Feature: StartAbilityImplicitModuleTest
149 * Function: StartAbility
150 * SubFunction: NA
151 * FunctionPoints: start ability by action
152 * EnvConditions: NA
153 * CaseDescription: start ability by action and type successful
154 */
155 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_001, TestSize.Level1)
156 {
157 EXPECT_TRUE(abilityMs_ != nullptr);
158
159 Want want;
160 want.SetAction(ACTION_VIEW);
161 want.SetType(WANT_TYPE);
162 want.SetParam("numMock", 3);
163
164 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
165 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
166 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
167 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
168
169 EXPECT_TRUE(!params.empty());
170 EXPECT_TRUE(isCallBack);
171
172 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
173 EXPECT_TRUE(abilityRecord != nullptr);
174
175 GTEST_LOG_(INFO) << "ability:" << abilityRecord->GetAbilityInfo().name;
176 GTEST_LOG_(INFO) << "bundle:" << abilityRecord->GetAbilityInfo().bundleName;
177 }
178
179 /*
180 * Feature: StartAbilityImplicitModuleTest
181 * Function: StartAbility
182 * SubFunction: NA
183 * FunctionPoints: start ability by action
184 * EnvConditions: NA
185 * CaseDescription: start ability by action and type successful
186 */
187 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_002, TestSize.Level1)
188 {
189 EXPECT_TRUE(abilityMs_ != nullptr);
190
191 Want want;
192 want.SetAction(ACTION_VIEW);
193 want.SetType(WANT_TYPE);
194 want.SetParam("numMock", 3);
195
196 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CLOSE);
197 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
198 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
199 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
200
201 EXPECT_TRUE(!params.empty());
202 EXPECT_TRUE(isCallBack);
203
204 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
205 EXPECT_TRUE(abilityRecord == nullptr);
206 }
207
208 /*
209 * Feature: StartAbilityImplicitModuleTest
210 * Function: StartAbility
211 * SubFunction: NA
212 * FunctionPoints: start ability by action
213 * EnvConditions: NA
214 * CaseDescription: start ability by action and type successful
215 */
216 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_003, TestSize.Level1)
217 {
218 EXPECT_TRUE(abilityMs_ != nullptr);
219
220 Want want;
221 want.SetAction(ACTION_VIEW);
222 want.SetType(WANT_TYPE);
223 want.SetParam("numMock", 1);
224
225 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
226 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
227 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
228 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
229
230 EXPECT_TRUE(params.empty());
231 EXPECT_TRUE(!isCallBack);
232
233 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
234 EXPECT_TRUE(abilityRecord != nullptr);
235 }
236
237 /*
238 * Feature: StartAbilityImplicitModuleTest
239 * Function: StartAbility
240 * SubFunction: NA
241 * FunctionPoints: start ability by action
242 * EnvConditions: NA
243 * CaseDescription: start ability by action and type successful
244 */
245 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_004, TestSize.Level1)
246 {
247 EXPECT_TRUE(abilityMs_ != nullptr);
248
249 Want want;
250 want.SetAction(ACTION_VIEW);
251 want.SetType(WANT_TYPE);
252 want.SetParam("numMock", 0);
253
254 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_TIPS_APP);
255 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
256 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
257 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
258
259 EXPECT_TRUE(!params.empty());
260 EXPECT_TRUE(isCallBack);
261
262 auto abilityRecord = abilityMs_->currentMissionListManager_->GetCurrentTopAbilityLocked();
263 EXPECT_TRUE(abilityRecord == nullptr);
264 }
265
266 /*
267 * Feature: StartAbilityImplicitModuleTest
268 * Function: StartAbility
269 * SubFunction: NA
270 * FunctionPoints: start ability by action
271 * EnvConditions: NA
272 * CaseDescription: start ability by action and type successful
273 */
274 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_005, TestSize.Level1)
275 {
276 EXPECT_TRUE(abilityMs_ != nullptr);
277
278 Want want;
279 want.SetAction(ACTION_VIEW);
280 want.SetParam("numMock", 3);
281
282 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
283 auto ret = abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
284
285 EXPECT_EQ(ret, ERR_OK);
286 }
287 }
288 }