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 #include "mission_list_manager.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS::AppExecFwk;
37 namespace {
38 const std::string EVENT_MULT_APP_CHOOSE = "EVENT_MULT_APP_CHOOSE";
39 const std::string EVENT_MULT_APP_CLOSE = "EVENT_MULT_APP_CLOSE";
40 const std::string EVENT_TIPS_APP = "EVENT_TIPS_APP";
41 const std::string ACTION_VIEW = "ohos.want.action.viewData";
42 const std::string WANT_TYPE = "image/png";
43 const int32_t MOCK_MAIN_USER_ID = 100;
44 }
45 namespace OHOS {
46 namespace AAFwk {
WaitUntilTaskFinished()47 static void WaitUntilTaskFinished()
48 {
49 const uint32_t maxRetryCount = 1000;
50 const uint32_t sleepTime = 1000;
51 uint32_t count = 0;
52 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
53 std::atomic<bool> taskCalled(false);
54 auto f = [&taskCalled]() { taskCalled.store(true); };
55 if (handler->SubmitTask(f)) {
56 while (!taskCalled.load()) {
57 ++count;
58 if (count >= maxRetryCount) {
59 break;
60 }
61 usleep(sleepTime);
62 }
63 }
64 }
65
66 class StartAbilityImplicitModuleTest : public testing::Test {
67 public:
68 static void TearDownTestCase();
69 void SetUp();
70 void TearDown();
71 void OnStartAms() const;
72 void OnStopAms() const;
73 static constexpr int TEST_WAIT_TIME = 100000;
74
75 public:
76 AbilityRequest abilityRequest_;
77 std::shared_ptr<AbilityRecord> abilityRecord_{ nullptr };
78 std::shared_ptr<AbilityManagerService> abilityMs_ = DelayedSingleton<AbilityManagerService>::GetInstance();
79 };
80
OnStartAms() const81 void StartAbilityImplicitModuleTest::OnStartAms() const
82 {
83 if (abilityMs_) {
84 if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) {
85 return;
86 }
87
88 abilityMs_->state_ = ServiceRunningState::STATE_RUNNING;
89 abilityMs_->taskHandler_ = TaskHandlerWrap::CreateQueueHandler("StartAbilityImplicitModuleTest");
90 // init user controller.
91 abilityMs_->userController_ = std::make_shared<UserController>();
92 EXPECT_TRUE(abilityMs_->userController_);
93 abilityMs_->userController_->Init();
94 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
95 abilityMs_->subManagersHelper_->InitSubManagers(MOCK_MAIN_USER_ID, true);
96
97 AmsConfigurationParameter::GetInstance().Parse();
98 abilityMs_->iBundleManager_ = new BundleMgrService();
99 EXPECT_TRUE(abilityMs_->iBundleManager_);
100
101 abilityMs_->implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
102 EXPECT_TRUE(abilityMs_->implicitStartProcessor_);
103 abilityMs_->implicitStartProcessor_->iBundleManager_ = new BundleMgrService();
104 EXPECT_TRUE(abilityMs_->implicitStartProcessor_->iBundleManager_);
105
106 DelayedSingleton<SystemDialogScheduler>::GetInstance()->SetDeviceType("phone");
107 abilityMs_->SwitchManagers(0, false);
108 abilityMs_->userController_->SetCurrentUserId(MOCK_MAIN_USER_ID);
109 return;
110 }
111
112 GTEST_LOG_(INFO) << "OnStart fail";
113 }
114
OnStopAms() const115 void StartAbilityImplicitModuleTest::OnStopAms() const
116 {
117 abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
118 abilityMs_->OnStop();
119 }
120
TearDownTestCase()121 void StartAbilityImplicitModuleTest::TearDownTestCase()
122 {
123 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
124 }
125
SetUp()126 void StartAbilityImplicitModuleTest::SetUp()
127 {
128 OnStartAms();
129 WaitUntilTaskFinished();
130 }
131
TearDown()132 void StartAbilityImplicitModuleTest::TearDown()
133 {
134 OnStopAms();
135 }
136
137 /*
138 * Feature: StartAbilityImplicitModuleTest
139 * Function: StartAbility
140 * SubFunction: NA
141 * FunctionPoints: start ability by action
142 * EnvConditions: NA
143 * CaseDescription: start ability by action and type successful
144 */
145 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_001, TestSize.Level1)
146 {
147 EXPECT_TRUE(abilityMs_ != nullptr);
148
149 Want want;
150 want.SetAction(ACTION_VIEW);
151 want.SetType(WANT_TYPE);
152 want.SetParam("numMock", 3);
153
154 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
155 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
156 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
157 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
158
159 EXPECT_TRUE(!params.empty());
160 EXPECT_TRUE(isCallBack);
161
162 auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
163 currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
164 EXPECT_TRUE(abilityRecord != nullptr);
165
166 GTEST_LOG_(INFO) << "ability:" << abilityRecord->GetAbilityInfo().name;
167 GTEST_LOG_(INFO) << "bundle:" << abilityRecord->GetAbilityInfo().bundleName;
168 }
169
170 /*
171 * Feature: StartAbilityImplicitModuleTest
172 * Function: StartAbility
173 * SubFunction: NA
174 * FunctionPoints: start ability by action
175 * EnvConditions: NA
176 * CaseDescription: start ability by action and type successful
177 */
178 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_002, TestSize.Level1)
179 {
180 EXPECT_TRUE(abilityMs_ != nullptr);
181
182 Want want;
183 want.SetAction(ACTION_VIEW);
184 want.SetType(WANT_TYPE);
185 want.SetParam("numMock", 3);
186
187 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CLOSE);
188 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
189 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
190 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
191
192 EXPECT_TRUE(!params.empty());
193 EXPECT_TRUE(isCallBack);
194
195 auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
196 currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
197 EXPECT_TRUE(abilityRecord == nullptr);
198 }
199
200 /*
201 * Feature: StartAbilityImplicitModuleTest
202 * Function: StartAbility
203 * SubFunction: NA
204 * FunctionPoints: start ability by action
205 * EnvConditions: NA
206 * CaseDescription: start ability by action and type successful
207 */
208 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_003, TestSize.Level1)
209 {
210 EXPECT_TRUE(abilityMs_ != nullptr);
211
212 Want want;
213 want.SetAction(ACTION_VIEW);
214 want.SetType(WANT_TYPE);
215 want.SetParam("numMock", 1);
216
217 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
218 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
219 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
220 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
221
222 EXPECT_TRUE(params.empty());
223 EXPECT_TRUE(!isCallBack);
224
225 auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
226 currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
227 EXPECT_TRUE(abilityRecord != nullptr);
228 }
229
230 /*
231 * Feature: StartAbilityImplicitModuleTest
232 * Function: StartAbility
233 * SubFunction: NA
234 * FunctionPoints: start ability by action
235 * EnvConditions: NA
236 * CaseDescription: start ability by action and type successful
237 */
238 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_004, TestSize.Level1)
239 {
240 EXPECT_TRUE(abilityMs_ != nullptr);
241
242 Want want;
243 want.SetAction(ACTION_VIEW);
244 want.SetType(WANT_TYPE);
245 want.SetParam("numMock", 0);
246
247 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_TIPS_APP);
248 abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
249 auto params = Ace::UIServiceMgrClient::GetInstance()->GetParams();
250 auto isCallBack = Ace::UIServiceMgrClient::GetInstance()->IsCallBack();
251
252 EXPECT_TRUE(!params.empty());
253 EXPECT_TRUE(isCallBack);
254
255 auto abilityRecord = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
256 currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
257 EXPECT_TRUE(abilityRecord == nullptr);
258 }
259
260 /*
261 * Feature: StartAbilityImplicitModuleTest
262 * Function: StartAbility
263 * SubFunction: NA
264 * FunctionPoints: start ability by action
265 * EnvConditions: NA
266 * CaseDescription: start ability by action and type successful
267 */
268 HWTEST_F(StartAbilityImplicitModuleTest, StartAbility_005, TestSize.Level1)
269 {
270 EXPECT_TRUE(abilityMs_ != nullptr);
271
272 Want want;
273 want.SetAction(ACTION_VIEW);
274 want.SetParam("numMock", 3);
275
276 Ace::UIServiceMgrClient::GetInstance()->SetDialogCheckState(EVENT_MULT_APP_CHOOSE);
277 auto ret = abilityMs_->StartAbility(want, MOCK_MAIN_USER_ID);
278
279 EXPECT_EQ(ret, ERR_OK);
280 }
281 }
282 }