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 <functional>
17 #include <chrono>
18 #include <thread>
19
20 #include "gtest/gtest.h"
21 #include "bgtask_common.h"
22 #include "background_task_subscriber.h"
23 #include "background_task_subscriber_proxy.h"
24 #include "bgtaskmgr_inner_errors.h"
25 #include "background_task_subscriber.h"
26 #include "bg_continuous_task_mgr.h"
27 #include "common_event_support.h"
28 #include "want_agent.h"
29
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace BackgroundTaskMgr {
34 namespace {
35 static constexpr int32_t SLEEP_TIME = 500;
36 static constexpr int32_t PROMPT_NUMS = 10;
37 static constexpr uint32_t LOCATION_BGMODE = 8;
38 static constexpr uint32_t BLUETOOTH_INTERACTION = 16;
39 static constexpr uint32_t BGMODE_WIFI_INTERACTION = 64;
40 static constexpr uint32_t BGMODE_VOIP = 128;
41 static constexpr uint32_t PC_BGMODE_TASK_KEEPING = 256;
42 static constexpr uint32_t LOCATION_BGMODE_ID = 4;
43 static constexpr uint32_t BGMODE_WIFI_INTERACTION_ID = 7;
44 static constexpr uint32_t BGMODE_VOIP_ID = 8;
45 static constexpr uint32_t BGMODE_TASK_KEEPING_ID = 9;
46 static constexpr uint32_t INVALID_BGMODE_ID = 11;
47 static constexpr uint64_t NO_SYSTEM_APP_TOKEN_ID = -100;
48 static constexpr int32_t DEFAULT_USERID = 100;
49 static constexpr int32_t TEST_NUM_ONE = 1;
50 static constexpr int32_t TEST_NUM_TWO = 2;
51 static constexpr int32_t TEST_NUM_THREE = 3;
52 static constexpr uint32_t CONFIGURE_ALL_MODES = 0x1FF;
53 static constexpr char BG_TASK_SUB_MODE_TYPE[] = "subMode";
54 }
55 class BgContinuousTaskMgrTest : public testing::Test {
56 public:
57 static void SetUpTestCase();
58 static void TearDownTestCase();
59 void SetUp();
60 void TearDown();
SleepForFC()61 inline void SleepForFC()
62 {
63 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
64 }
65
66 static std::shared_ptr<BgContinuousTaskMgr> bgContinuousTaskMgr_;
67 };
68
69 std::shared_ptr<BgContinuousTaskMgr> BgContinuousTaskMgrTest::bgContinuousTaskMgr_ = nullptr;
70
SetUpTestCase()71 void BgContinuousTaskMgrTest::SetUpTestCase()
72 {
73 bgContinuousTaskMgr_ = BgContinuousTaskMgr::GetInstance();
74 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskText_), PROMPT_NUMS, "bgmode_test");
75 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskSubText_), PROMPT_NUMS, "bgmsubmode_test");
76 bgContinuousTaskMgr_->isSysReady_.store(true);
77 }
78
TearDownTestCase()79 void BgContinuousTaskMgrTest::TearDownTestCase() {}
80
SetUp()81 void BgContinuousTaskMgrTest::SetUp() {}
82
TearDown()83 void BgContinuousTaskMgrTest::TearDown()
84 {
85 std::vector<string> dumpOption;
86 dumpOption.emplace_back("-C");
87 dumpOption.emplace_back("--cancel_all");
88 std::vector<string> dumpInfo;
89 bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo);
90 }
91
92 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {
93 public:
OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)94 void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo>
95 &continuousTaskCallbackInfo) override {}
96
OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)97 void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo>
98 &continuousTaskCallbackInfo) override {}
99 };
100
101 /**
102 * @tc.name: StartBackgroundRunning_001
103 * @tc.desc: start background runnging use new api test.
104 * @tc.type: FUNC
105 * @tc.require: SR000GGT7U AR000GH6ER AR000GH6EM AR000GH6EN AR000GH6EO
106 */
107 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_001, TestSize.Level1)
108 {
109 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
110 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
111 EXPECT_NE(taskParam, nullptr);
112 taskParam->appName_ = "Entry";
113 taskParam->isNewApi_ = true;
114 taskParam->abilityId_ = 1;
115 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
116 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
117 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
118 taskParam->abilityName_ = "";
119 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
120 taskParam->abilityName_ = "ability1";
121 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
122 taskParam->bgModeId_ = 9;
123 taskParam->bgModeIds_.clear();
124 EXPECT_NE((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), -1);
125 taskParam->bgModeId_ = 1;
126 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
127 taskParam->bgModeId_ = 4;
128 CachedBundleInfo info = CachedBundleInfo();
129 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
130 info.appName_ = "Entry";
131 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
132 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
133 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
134 }
135
136 /**
137 * @tc.name: StartBackgroundRunning_002
138 * @tc.desc: start background runnging use old api test.
139 * @tc.type: FUNC
140 * @tc.require: SR000GGT7T AR000GH6ER AR000GH6EP AR000GJ9PR AR000GH6G8
141 */
142 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_002, TestSize.Level1)
143 {
144 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
145 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
146 EXPECT_NE(taskParam, nullptr);
147 taskParam->appName_ = "Entry";
148 taskParam->isNewApi_ = false;
149 taskParam->bgModeId_ = 0;
150 taskParam->abilityName_ = "";
151 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
152 taskParam->abilityName_ = "ability1";
153 CachedBundleInfo info = CachedBundleInfo();
154 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
155 info.appName_ = "Entry";
156 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
157 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
158 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
159 }
160
161 /**
162 * @tc.name: StartBackgroundRunning_003
163 * @tc.desc: start background runnging by abilityIds test.
164 * @tc.type: FUNC
165 * @tc.require: issueI99HSB
166 */
167 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_003, TestSize.Level1)
168 {
169 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
170 int taskSize = 0;
171 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
172 CachedBundleInfo info = CachedBundleInfo();
173 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
174 info.appName_ = "Entry";
175 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
176
177 // start one task by abilityId is 1
178 sptr<ContinuousTaskParam> taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 0,
179 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
180 "ability1", nullptr, "Entry", true, {1, 2, 3}, 1);
181 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam1), (int32_t)ERR_OK);
182
183 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
184 EXPECT_EQ(taskSize, 1);
185
186 int32_t abilityId = -1;
187 std::unordered_map<std::string, std::shared_ptr<ContinuousTaskRecord>>::iterator iter;
188 for (iter = bgContinuousTaskMgr_->continuousTaskInfosMap_.begin();
189 iter != bgContinuousTaskMgr_->continuousTaskInfosMap_.end(); ++iter) {
190 abilityId = iter->second->GetAbilityId();
191 }
192 EXPECT_EQ(abilityId, 1);
193
194 // start one task by abilityId is 2
195 sptr<ContinuousTaskParam> taskParam2 = new (std::nothrow) ContinuousTaskParam(true, 0,
196 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
197 "ability1", nullptr, "Entry", true, {1, 2, 3}, 2);
198 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam2), (int32_t)ERR_OK);
199
200 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
201 EXPECT_EQ(taskSize, 2);
202
203 // agent start one task by abilityId is 2
204 sptr<ContinuousTaskParam> taskParam3 = new (std::nothrow) ContinuousTaskParam(true, 0,
205 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
206 "ability1", nullptr, "Entry", true, {1, 2, 3}, 2);
207 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam3),
208 (int32_t)ERR_BGTASK_OBJECT_EXISTS);
209
210 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
211 EXPECT_EQ(taskSize, 2);
212
213 // stop one task by abilityId is 1
214 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam1->abilityName_, 1), (int32_t)ERR_OK);
215
216 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
217 EXPECT_EQ(taskSize, 1);
218
219 // stop one task by abilityId is 2
220 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 2), (int32_t)ERR_OK);
221
222 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
223 EXPECT_EQ(taskSize, 0);
224
225 // agent stop one task by abilityId is 2
226 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 2),
227 (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
228
229 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
230 EXPECT_EQ(taskSize, 0);
231 }
232
233 /**
234 * @tc.name: StartAndUpdateBackgroundRunning_001
235 * @tc.desc: use batch api.
236 * @tc.type: FUNC
237 * @tc.require: issueI94UH9 issueI99HSB
238 */
239 HWTEST_F(BgContinuousTaskMgrTest, StartAndUpdateBackgroundRunning_001, TestSize.Level1)
240 {
241 // 1 modes is empty
242 sptr<ContinuousTaskParam> taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 0,
243 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
244 "ability1", nullptr, "Entry", true, {});
245 EXPECT_NE(taskParam1, nullptr);
246 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam1), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
247
248 // 2 set configure mode is CONFIGURE_ALL_MODES
249 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
250 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 0u);
251 CachedBundleInfo info = CachedBundleInfo();
252 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
253 info.appName_ = "Entry";
254 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
255
256 // 3 start ok
257 sptr<ContinuousTaskParam> taskParam2 = new (std::nothrow) ContinuousTaskParam(true, 0,
258 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
259 "ability1", nullptr, "Entry", true, {1, 2, 3}, 1);
260 EXPECT_NE(taskParam2, nullptr);
261 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam2), (int32_t)ERR_OK);
262
263 // 4 update ok
264 sptr<ContinuousTaskParam> taskParam3 = new (std::nothrow) ContinuousTaskParam(true, 0,
265 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
266 "ability1", nullptr, "Entry", true, {4}, 1);
267 EXPECT_NE(taskParam3, nullptr);
268 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam3), (int32_t)ERR_OK);
269
270 // 5 update invalid
271 sptr<ContinuousTaskParam> taskParam4 = new (std::nothrow) ContinuousTaskParam(true, 0,
272 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
273 "ability1", nullptr, "Entry", true, {10}, 1);
274 EXPECT_NE(taskParam4, nullptr);
275 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam4), (int32_t)ERR_BGTASK_INVALID_BGMODE);
276
277 // 6 stop ok
278 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 1), (int32_t)ERR_OK);
279
280 // 7 no start then update error
281 sptr<ContinuousTaskParam> taskParam5 = new (std::nothrow) ContinuousTaskParam(true, 0,
282 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
283 "ability1", nullptr, "Entry", true, {1, 2});
284 EXPECT_NE(taskParam5, nullptr);
285 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam5), (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
286 }
287
288 /**
289 * @tc.name: StopBackgroundRunning_001
290 * @tc.desc: stop background runnging test.
291 * @tc.type: FUNC
292 * @tc.require: SR000GGT7V AR000GH6ES AR000GH6EM AR000GH6G9 AR000GH56K issueI99HSB
293 */
294 HWTEST_F(BgContinuousTaskMgrTest, StopBackgroundRunning_001, TestSize.Level1)
295 {
296 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
297 EXPECT_NE(taskParam, nullptr);
298 taskParam->appName_ = "Entry";
299 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
300 taskParam->abilityName_ = "ability1";
301 taskParam->bgModeId_ = 4;
302 taskParam->abilityId_ = 1;
303 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("", 1), (int32_t)ERR_BGTASK_INVALID_PARAM);
304 SleepForFC();
305 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1),
306 (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
307 SleepForFC();
308 bgContinuousTaskMgr_->StartBackgroundRunning(taskParam);
309 SleepForFC();
310 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1), (int32_t)ERR_OK);
311 }
312
313 /**
314 * @tc.name: StopBackgroundRunning_002
315 * @tc.desc: stop background runnging test.
316 * @tc.type: FUNC
317 * @tc.require: issues#I8FWJH issueI99HSB
318 */
319 HWTEST_F(BgContinuousTaskMgrTest, StopBackgroundRunning_002, TestSize.Level1)
320 {
321 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
322 EXPECT_NE(taskParam, nullptr);
323 taskParam->appName_ = "Entry";
324 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
325 taskParam->abilityName_ = "ability1";
326 taskParam->bgModeId_ = 2;
327 taskParam->abilityId_ = 1;
328 bgContinuousTaskMgr_->StartBackgroundRunning(taskParam);
329 SleepForFC();
330 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1), (int32_t)ERR_OK);
331 }
332
333 /**
334 * @tc.name: SubscribeContinuousTask_001
335 * @tc.desc: subscribe continuous task event callback test.
336 * @tc.type: FUNC
337 * @tc.require: SR000GGT81 AR000GH6EM AR000GH6G9 AR000GH6ET
338 */
339 HWTEST_F(BgContinuousTaskMgrTest, SubscribeContinuousTask_001, TestSize.Level1)
340 {
341 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(nullptr), (int32_t)ERR_BGTASK_INVALID_PARAM);
342 SleepForFC();
343 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
344 EXPECT_NE(subscriber, nullptr);
345 auto info = std::make_shared<SubscriberInfo>(subscriber->GetImpl(), 1, 1, 0);
346 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(info), (int32_t)ERR_OK);
347 }
348
349 /**
350 * @tc.name: UnsubscribeContinuousTask_001
351 * @tc.desc: unsubscribe continuous task event callback test.
352 * @tc.type: FUNC
353 * @tc.require: SR000GGT7U AR000GH6EM AR000GH6G9 AR000GH6ET
354 */
355 HWTEST_F(BgContinuousTaskMgrTest, UnsubscribeContinuousTask_001, TestSize.Level1)
356 {
357 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
358 EXPECT_NE(subscriber, nullptr);
359 auto info = std::make_shared<SubscriberInfo>(subscriber->GetImpl(), 1, 1, 0);
360 bgContinuousTaskMgr_->AddSubscriber(info);
361 SleepForFC();
362 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->RemoveSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
363 }
364
365 /**
366 * @tc.name: BgTaskManagerUnitTest_002
367 * @tc.desc: test SetCachedBundleInfo.
368 * @tc.type: FUNC
369 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
370 */
371 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_002, TestSize.Level1)
372 {
373 EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "false-test", "test"));
374 EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "empty-info", "test"));
375 EXPECT_TRUE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "valid", "test"));
376 }
377
378 /**
379 * @tc.name: BgTaskManagerUnitTest_003
380 * @tc.desc: test CheckBgmodeType.
381 * @tc.type: FUNC
382 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
383 */
384 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_003, TestSize.Level1)
385 {
386 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(0, 1, false, 1ULL), ERR_BGMODE_NULL_OR_TYPE_ERR);
387 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(1, 1, false, 1ULL), ERR_OK);
388 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
389 true, NO_SYSTEM_APP_TOKEN_ID), ERR_BGTASK_NOT_SYSTEM_APP);
390 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, NO_SYSTEM_APP_TOKEN_ID),
391 ERR_OK);
392 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
393 true, 1ULL), ERR_OK);
394 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, 1ULL), ERR_OK);
395 if (SUPPORT_TASK_KEEPING) {
396 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true, 1ULL),
397 ERR_OK);
398 } else {
399 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true, 1ULL),
400 ERR_BGTASK_KEEPING_TASK_VERIFY_ERR);
401 }
402 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, 1ULL), ERR_OK);
403 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(LOCATION_BGMODE, LOCATION_BGMODE_ID, true, 1ULL), ERR_OK);
404 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BLUETOOTH_INTERACTION, LOCATION_BGMODE_ID, true, 1ULL),
405 ERR_BGTASK_INVALID_BGMODE);
406 }
407
408 /**
409 * @tc.name: BgTaskManagerUnitTest_004
410 * @tc.desc: test GetBackgroundModeInfo.
411 * @tc.type: FUNC
412 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
413 */
414 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_004, TestSize.Level1)
415 {
416 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
417 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 0u);
418
419 CachedBundleInfo info = CachedBundleInfo();
420 info.abilityBgMode_["abilityName"] = 1;
421 info.appName_ = "appName";
422 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
423
424 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "test"), 0u);
425 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 1u);
426 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
427 }
428
429 /**
430 * @tc.name: BgTaskManagerUnitTest_005
431 * @tc.desc: test SendContinuousTaskNotification.
432 * @tc.type: FUNC
433 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
434 */
435 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_005, TestSize.Level1)
436 {
437 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
438 continuousTaskRecord->bgModeId_ = 1;
439 continuousTaskRecord->bgModeIds_.clear();
440 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
441 continuousTaskRecord->isNewApi_ = false;
442 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
443 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
444 continuousTaskRecord->isNewApi_ = true;
445 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
446 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
447 continuousTaskRecord->bgModeId_ = INVALID_BGMODE_ID;
448 continuousTaskRecord->bgModeIds_.clear();
449 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
450 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
451 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
452
453 CachedBundleInfo info = CachedBundleInfo();
454 info.abilityBgMode_["abilityName"] = 1;
455 info.appName_ = "appName";
456 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
457 continuousTaskRecord->uid_ = 1;
458 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
459 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
460 continuousTaskRecord->bgModeId_ = 1;
461 continuousTaskRecord->bgModeIds_.clear();
462 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
463 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
464 }
465
466 /**
467 * @tc.name: BgTaskManagerUnitTest_006
468 * @tc.desc: test StopContinuousTask.
469 * @tc.type: FUNC
470 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
471 */
472 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_006, TestSize.Level1)
473 {
474 bgContinuousTaskMgr_->isSysReady_.store(false);
475 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
476 bgContinuousTaskMgr_->isSysReady_.store(true);
477 bgContinuousTaskMgr_->StopContinuousTask(-1, 1, 1, "");
478 SleepForFC();
479 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
480 SleepForFC();
481
482 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
483 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
484 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
485 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
486 continuousTaskRecord2->uid_ = TEST_NUM_ONE;
487 continuousTaskRecord2->bgModeId_ = TEST_NUM_THREE;
488 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord3 = std::make_shared<ContinuousTaskRecord>();
489 continuousTaskRecord3->uid_ = TEST_NUM_TWO;
490 continuousTaskRecord3->bgModeId_ = TEST_NUM_TWO;
491 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord4 = std::make_shared<ContinuousTaskRecord>();
492 continuousTaskRecord4->uid_ = TEST_NUM_TWO;
493 continuousTaskRecord4->bgModeId_ = TEST_NUM_THREE;
494
495 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
496 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
497 bgContinuousTaskMgr_->continuousTaskInfosMap_["key3"] = continuousTaskRecord3;
498 bgContinuousTaskMgr_->continuousTaskInfosMap_["key4"] = continuousTaskRecord4;
499 bgContinuousTaskMgr_->StopContinuousTask(-1, 1, 1, "");
500 SleepForFC();
501 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
502
503 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
504 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
505 bgContinuousTaskMgr_->continuousTaskInfosMap_["key3"] = continuousTaskRecord3;
506 bgContinuousTaskMgr_->continuousTaskInfosMap_["key4"] = continuousTaskRecord4;
507 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
508 SleepForFC();
509 EXPECT_TRUE(true);
510 }
511
512 /**
513 * @tc.name: BgTaskManagerUnitTest_007
514 * @tc.desc: test GetContinuousTaskApps.
515 * @tc.type: FUNC
516 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
517 */
518 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_007, TestSize.Level1)
519 {
520 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
521 bgContinuousTaskMgr_->isSysReady_.store(false);
522 std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list;
523 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_BGTASK_SYS_NOT_READY);
524 bgContinuousTaskMgr_->isSysReady_.store(true);
525 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
526
527
528 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
529 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
530 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
531 }
532
533 /**
534 * @tc.name: BgTaskManagerUnitTest_008
535 * @tc.desc: test ShellDump.
536 * @tc.type: FUNC
537 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
538 */
539 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_008, TestSize.Level1)
540 {
541 bgContinuousTaskMgr_->isSysReady_.store(false);
542 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
543 std::vector<std::string> dumpOption;
544 dumpOption.emplace_back("-C");
545 std::vector<std::string> dumpInfo;
546 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_SYS_NOT_READY);
547 bgContinuousTaskMgr_->isSysReady_.store(true);
548 dumpOption.emplace_back("--all");
549 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
550 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
551 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
552 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
553 dumpOption.pop_back();
554 dumpOption.emplace_back("--cancel_all");
555 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
556 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
557 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
558 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
559 dumpOption.pop_back();
560 dumpOption.emplace_back("--cancel");
561 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
562 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
563 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
564 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
565 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
566 dumpOption.pop_back();
567 dumpOption.emplace_back("invalid");
568 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
569 }
570
571 /**
572 * @tc.name: BgTaskManagerUnitTest_009
573 * @tc.desc: test RemoveContinuousTaskRecord.
574 * @tc.type: FUNC
575 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
576 */
577 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_009, TestSize.Level1)
578 {
579 EXPECT_FALSE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
580 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
581 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
582 EXPECT_TRUE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
583 }
584
585 /**
586 * @tc.name: BgTaskManagerUnitTest_010
587 * @tc.desc: test StopContinuousTaskByUser.
588 * @tc.type: FUNC
589 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
590 */
591 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_010, TestSize.Level1)
592 {
593 bgContinuousTaskMgr_->isSysReady_.store(false);
594 EXPECT_FALSE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
595 bgContinuousTaskMgr_->isSysReady_.store(true);
596 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
597 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
598 EXPECT_TRUE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
599 }
600
601 /**
602 * @tc.name: BgTaskManagerUnitTest_011
603 * @tc.desc: test OnRemoteSubscriberDied.
604 * @tc.type: FUNC
605 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
606 */
607 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_011, TestSize.Level1)
608 {
609 bgContinuousTaskMgr_->isSysReady_.store(false);
610 bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
611 bgContinuousTaskMgr_->isSysReady_.store(true);
612 bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
613 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
614 auto info1 = std::make_shared<SubscriberInfo>(subscriber1.GetImpl(), 1, 1, 0);
615 TestBackgroundTaskSubscriber subscriber2 = TestBackgroundTaskSubscriber();
616 auto info2 = std::make_shared<SubscriberInfo>(subscriber2.GetImpl(), 1, 1, 0);
617 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info1);
618 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info2);
619 bgContinuousTaskMgr_->OnRemoteSubscriberDied(subscriber1.GetImpl());
620 EXPECT_TRUE(true);
621 }
622
623 /**
624 * @tc.name: BgTaskManagerUnitTest_012
625 * @tc.desc: test OnAbilityStateChanged.
626 * @tc.type: FUNC
627 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB
628 */
629 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_012, TestSize.Level1)
630 {
631 bgContinuousTaskMgr_->isSysReady_.store(false);
632 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
633 bgContinuousTaskMgr_->isSysReady_.store(true);
634 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
635
636 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
637 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
638 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
639 continuousTaskRecord->uid_ = 1;
640 continuousTaskRecord->abilityName_ = "test";
641 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
642 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
643 bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test1", -1);
644 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test1", -1);
645 bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test", -1);
646 EXPECT_TRUE(true);
647 }
648
649 /**
650 * @tc.name: BgTaskManagerUnitTest_013
651 * @tc.desc: test OnAppStopped.
652 * @tc.type: FUNC
653 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueIALCBZ
654 */
655 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_013, TestSize.Level1)
656 {
657 bgContinuousTaskMgr_->isSysReady_.store(false);
658 bgContinuousTaskMgr_->OnAppStopped(1);
659 bgContinuousTaskMgr_->isSysReady_.store(true);
660 bgContinuousTaskMgr_->OnAppStopped(1);
661
662 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
663 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
664 continuousTaskRecord->uid_ = 1;
665 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
666 bgContinuousTaskMgr_->OnAppStopped(-1);
667 bgContinuousTaskMgr_->OnAppStopped(1);
668 EXPECT_TRUE(true);
669 }
670
671 /**
672 * @tc.name: BgTaskManagerUnitTest_014
673 * @tc.desc: test OnContinuousTaskChanged.
674 * @tc.type: FUNC
675 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
676 */
677 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_014, TestSize.Level1)
678 {
679 bgContinuousTaskMgr_->OnContinuousTaskChanged(nullptr, ContinuousTaskEventTriggerType::TASK_START);
680 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
681 auto continuousTaskInfo = std::make_shared<ContinuousTaskRecord>();
682 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
683 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
684 auto info = std::make_shared<SubscriberInfo>(subscriber.GetImpl(), 1, 1, 0);
685 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info);
686 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
687 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_UPDATE);
688 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_CANCEL);
689 EXPECT_TRUE(true);
690 }
691
692 /**
693 * @tc.name: BgTaskManagerUnitTest_015
694 * @tc.desc: test OnBundleInfoChanged.
695 * @tc.type: FUNC
696 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
697 */
698 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_015, TestSize.Level1)
699 {
700 bgContinuousTaskMgr_->isSysReady_.store(false);
701 bgContinuousTaskMgr_->OnBundleInfoChanged("action", "bundleName", -1);
702 bgContinuousTaskMgr_->isSysReady_.store(true);
703 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED,
704 "bundleName", -1);
705
706 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
707 "bundleName", -1);
708
709 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
710 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
711 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
712 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
713 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
714 continuousTaskRecord2->uid_ = TEST_NUM_TWO;
715 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
716 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
717 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
718 "bundleName", 1);
719 EXPECT_TRUE(true);
720 }
721
722 /**
723 * @tc.name: BgTaskManagerUnitTest_016
724 * @tc.desc: test OnAccountsStateChanged.
725 * @tc.type: FUNC
726 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
727 */
728 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_016, TestSize.Level1)
729 {
730 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
731 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
732
733 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
734 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
735 continuousTaskRecord1->userId_ = 1;
736 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
737 continuousTaskRecord2->userId_ = DEFAULT_USERID;
738 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
739 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
740 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
741 EXPECT_TRUE(true);
742 }
743
744 /**
745 * @tc.name: BgTaskManagerUnitTest_017
746 * @tc.desc: test HandleAppContinuousTaskStop.
747 * @tc.type: FUNC
748 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
749 */
750 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_017, TestSize.Level1)
751 {
752 bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
753 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
754 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
755 continuousTaskRecord->uid_ = 1;
756 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
757 bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
758 EXPECT_TRUE(true);
759 }
760
761 /**
762 * @tc.name: BgTaskManagerUnitTest_033
763 * @tc.desc: test CheckPersistenceData.
764 * @tc.type: FUNC
765 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
766 */
767 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_033, TestSize.Level1)
768 {
769 #ifdef DISTRIBUTED_NOTIFICATION_ENABLE
770 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
771 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
772 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
773 continuousTaskRecord1->notificationLabel_ = "label1";
774
775 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
776 continuousTaskRecord2->pid_ = TEST_NUM_TWO;
777 continuousTaskRecord2->notificationLabel_ = "label1";
778 continuousTaskRecord2->notificationId_ = 100;
779
780 std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
781 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
782 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
783 bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
784 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
785
786 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
787 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
788 AppExecFwk::RunningProcessInfo processInfo1;
789 processInfo1.pid_ = TEST_NUM_ONE;
790 AppExecFwk::RunningProcessInfo processInfo2;
791 processInfo2.pid_ = TEST_NUM_TWO;
792 allProcesses.push_back(processInfo1);
793 allProcesses.push_back(processInfo2);
794 bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
795 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
796 #endif
797 }
798
799 /**
800 * @tc.name: BgTaskManagerUnitTest_034
801 * @tc.desc: test HandleStopContinuousTask.
802 * @tc.type: FUNC
803 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
804 */
805 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_034, TestSize.Level1)
806 {
807 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
808 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
809 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
810 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
811 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
812 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
813 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
814
815 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
816 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
817 bgContinuousTaskMgr_->HandleStopContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, TEST_NUM_ONE, "");
818 EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
819 }
820
821 /**
822 * @tc.name: BgTaskManagerUnitTest_035
823 * @tc.desc: test HandleStopContinuousTask.
824 * @tc.type: FUNC
825 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
826 */
827 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_035, TestSize.Level1)
828 {
829 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
830 bgContinuousTaskMgr_->HandleStopContinuousTask(0, 0, 0, "");
831 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
832
833 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
834 continuousTaskRecord1->uid_ = 1;
835 continuousTaskRecord1->bgModeIds_ = {1};
836 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
837 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
838
839 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 1, "");
840 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
841
842 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
843 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
844 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0xFF, "");
845 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
846
847 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
848 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
849 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0, "key1");
850 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
851 }
852
853 /**
854 * @tc.name: BgTaskManagerUnitTest_036
855 * @tc.desc: test SubscriberChange.
856 * @tc.type: FUNC
857 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
858 */
859 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_036, TestSize.Level1)
860 {
861 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
862 auto info = std::make_shared<SubscriberInfo>(subscriber1.GetImpl(), 1, 1, 0);
863 bgContinuousTaskMgr_->AddSubscriberInner(info);
864 EXPECT_EQ(bgContinuousTaskMgr_->AddSubscriberInner(info), ERR_BGTASK_OBJECT_EXISTS);
865 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
866 EXPECT_EQ(bgContinuousTaskMgr_->RemoveSubscriberInner(subscriber1.GetImpl()), ERR_BGTASK_INVALID_PARAM);
867 }
868
869 /**
870 * @tc.name: BgTaskManagerUnitTest_037
871 * @tc.desc: test DumpAllTaskInfo.
872 * @tc.type: FUNC
873 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
874 */
875 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_037, TestSize.Level1)
876 {
877 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
878 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
879 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
880 continuousTaskRecord1->notificationLabel_ = "label1";
881
882 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
883 info->bundleName_ = "wantAgentBundleName";
884 info->abilityName_ = "wantAgentAbilityName";
885 continuousTaskRecord1->wantAgentInfo_ = info;
886 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
887 std::vector<std::string> dumpInfo;
888 bgContinuousTaskMgr_->DumpAllTaskInfo(dumpInfo);
889 EXPECT_NE((int32_t)dumpInfo.size(), 0);
890 }
891
892 /**
893 * @tc.name: BgTaskManagerUnitTest_038
894 * @tc.desc: test DumpCancelTask.
895 * @tc.type: FUNC
896 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
897 */
898 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_038, TestSize.Level1)
899 {
900 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
901 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
902 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
903 continuousTaskRecord1->notificationLabel_ = "label1";
904
905 std::vector<std::string> dumpOption;
906 dumpOption.emplace_back("param1");
907 dumpOption.emplace_back("param2");
908 dumpOption.emplace_back("key1");
909
910 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
911 bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
912 dumpOption.pop_back();
913 dumpOption.emplace_back("key2");
914 bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
915 EXPECT_NE((int32_t)dumpOption.size(), 0);
916 }
917
918 /**
919 * @tc.name: BgTaskManagerUnitTest_039
920 * @tc.desc: test OnConfigurationChanged.
921 * @tc.type: FUNC
922 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
923 */
924 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_039, TestSize.Level1)
925 {
926 AppExecFwk::Configuration configuration;
927 bgContinuousTaskMgr_->isSysReady_.store(false);
928 bgContinuousTaskMgr_->OnConfigurationChanged(configuration);
929 bgContinuousTaskMgr_->isSysReady_.store(true);
930
931 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
932 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
933 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
934 continuousTaskRecord1->isNewApi_ = true;
935
936 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
937 continuousTaskRecord2->bgModeId_ = INVALID_BGMODE_ID;
938 continuousTaskRecord1->isNewApi_ = true;
939
940 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
941 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
942 EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
943 }
944
945 /**
946 * @tc.name: BgTaskManagerUnitTest_043
947 * @tc.desc: test RequestBackgroundRunningForInner.
948 * @tc.type: FUNC
949 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
950 */
951 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_043, TestSize.Level1)
952 {
953 bgContinuousTaskMgr_->isSysReady_.store(false);
954 EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_SYS_NOT_READY);
955 bgContinuousTaskMgr_->isSysReady_.store(true);
956 EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_CHECK_TASK_PARAM);
957 sptr<ContinuousTaskParamForInner> taskParam = sptr<ContinuousTaskParamForInner>(
958 new ContinuousTaskParamForInner(1, 1, true));
959 EXPECT_EQ(bgContinuousTaskMgr_->StartBackgroundRunningForInner(taskParam), ERR_OK);
960 taskParam->isStart_ = false;
961 EXPECT_EQ(bgContinuousTaskMgr_->StopBackgroundRunningForInner(taskParam), ERR_OK);
962 }
963
964 /**
965 * @tc.name: BgTaskManagerUnitTest_044
966 * @tc.desc: test CheckBgmodeTypeForInner.
967 * @tc.type: FUNC
968 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
969 */
970 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_044, TestSize.Level1)
971 {
972 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(0), ERR_BGTASK_INVALID_BGMODE);
973 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(1), ERR_OK);
974 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(10), ERR_OK);
975 }
976
977 /**
978 * @tc.name: BgTaskManagerUnitTest_045
979 * @tc.desc: test CheckProcessUidInfo.
980 * @tc.type: FUNC
981 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
982 */
983 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_045, TestSize.Level1)
984 {
985 std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
986
987 AppExecFwk::RunningProcessInfo info1;
988 info1.uid_ = TEST_NUM_ONE;
989 allProcesses.push_back(info1);
990 EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), false);
991 AppExecFwk::RunningProcessInfo info2;
992 info2.uid_ = TEST_NUM_TWO;
993 allProcesses.push_back(info2);
994 EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), true);
995 }
996
997 /**
998 * @tc.name: BgTaskManagerUnitTest_046
999 * @tc.desc: test SendContinuousTaskNotification.
1000 * @tc.type: FUNC
1001 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
1002 */
1003 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_046, TestSize.Level1)
1004 {
1005 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1006 continuousTaskRecord->bgModeId_ = 2;
1007 continuousTaskRecord->isNewApi_ = true;
1008 continuousTaskRecord->uid_ = 1;
1009
1010 CachedBundleInfo info = CachedBundleInfo();
1011 info.abilityBgMode_["abilityName"] = 2;
1012 info.appName_ = "appName";
1013 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
1014
1015 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
1016 }
1017
1018 /**
1019 * @tc.name: BgTaskManagerUnitTest_047
1020 * @tc.desc: test GetNotificationText.
1021 * @tc.type: FUNC
1022 * @tc.require: issueIBOIHY
1023 */
1024 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_047, TestSize.Level1)
1025 {
1026 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1027 continuousTaskRecord->bgModeIds_.push_back(2);
1028 EXPECT_EQ(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1029
1030 continuousTaskRecord->bgModeIds_.push_back(1);
1031 EXPECT_NE(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1032
1033 continuousTaskRecord->bgSubModeIds_.push_back(1);
1034 EXPECT_NE(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1035 }
1036
1037 /**
1038 * @tc.name: BgTaskManagerUnitTest_048
1039 * @tc.desc: test CheckSubMode.
1040 * @tc.type: FUNC
1041 * @tc.require: issueIBOIHY
1042 */
1043 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_048, TestSize.Level1)
1044 {
1045 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1046 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1047 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_OK);
1048
1049 want->SetParam(BG_TASK_SUB_MODE_TYPE, 0);
1050 continuousTaskRecord->bgModeIds_.push_back(1);
1051 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_BGTASK_CHECK_TASK_PARAM);
1052
1053 want->SetParam(BG_TASK_SUB_MODE_TYPE, 1);
1054 continuousTaskRecord->bgModeIds_.push_back(1);
1055 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_BGTASK_CHECK_TASK_PARAM);
1056
1057 continuousTaskRecord->bgModeIds_.push_back(5);
1058 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_OK);
1059 }
1060
1061 /**
1062 * @tc.name: BgTaskManagerUnitTest_049
1063 * @tc.desc: test CheckNotificationText.
1064 * @tc.type: FUNC
1065 * @tc.require: issueIBOIHY
1066 */
1067 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_049, TestSize.Level1)
1068 {
1069 std::string notificationText {""};
1070 std::shared_ptr<ContinuousTaskRecord> record = std::make_shared<ContinuousTaskRecord>();
1071 record->bgModeIds_.clear();
1072 record->bgModeIds_.push_back(2);
1073 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record), ERR_OK);
1074
1075 record->bgModeIds_.clear();
1076 record->bgModeIds_.push_back(100);
1077 bgContinuousTaskMgr_->continuousTaskText_.clear();
1078 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record),
1079 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
1080
1081 record->bgModeIds_.clear();
1082 record->bgModeIds_.push_back(5);
1083 record->bgSubModeIds_.push_back(1);
1084 bgContinuousTaskMgr_->continuousTaskSubText_.clear();
1085 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskText_), PROMPT_NUMS, "bgmmode_test");
1086 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record),
1087 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
1088
1089 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskSubText_), PROMPT_NUMS, "bgmsubmode_test");
1090 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record), ERR_OK);
1091 }
1092 } // namespace BackgroundTaskMgr
1093 } // namespace OHOS