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