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     EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
344 }
345 
346 /**
347  * @tc.name: UnsubscribeContinuousTask_001
348  * @tc.desc: unsubscribe continuous task event callback test.
349  * @tc.type: FUNC
350  * @tc.require: SR000GGT7U AR000GH6EM AR000GH6G9 AR000GH6ET
351  */
352 HWTEST_F(BgContinuousTaskMgrTest, UnsubscribeContinuousTask_001, TestSize.Level1)
353 {
354     auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
355     EXPECT_NE(subscriber, nullptr);
356     bgContinuousTaskMgr_->AddSubscriber(subscriber->GetImpl());
357     SleepForFC();
358     EXPECT_EQ((int32_t)bgContinuousTaskMgr_->RemoveSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
359 }
360 
361 /**
362  * @tc.name: BgTaskManagerUnitTest_002
363  * @tc.desc: test SetCachedBundleInfo.
364  * @tc.type: FUNC
365  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
366  */
367 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_002, TestSize.Level1)
368 {
369     EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "false-test", "test"));
370     EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "empty-info", "test"));
371     EXPECT_TRUE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "valid", "test"));
372 }
373 
374 /**
375  * @tc.name: BgTaskManagerUnitTest_003
376  * @tc.desc: test CheckBgmodeType.
377  * @tc.type: FUNC
378  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
379  */
380 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_003, TestSize.Level1)
381 {
382     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(0, 1, false, 1ULL), ERR_BGMODE_NULL_OR_TYPE_ERR);
383     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(1, 1, false, 1ULL), ERR_OK);
384     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
385         true, NO_SYSTEM_APP_TOKEN_ID), ERR_BGTASK_NOT_SYSTEM_APP);
386     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, NO_SYSTEM_APP_TOKEN_ID),
387         ERR_OK);
388     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
389         true, 1ULL), ERR_OK);
390     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, 1ULL), ERR_OK);
391     if (SUPPORT_TASK_KEEPING) {
392         EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true, 1ULL),
393             ERR_OK);
394     } else {
395         EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true, 1ULL),
396             ERR_BGTASK_KEEPING_TASK_VERIFY_ERR);
397     }
398     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, 1ULL), ERR_OK);
399     bgContinuousTaskMgr_->deviceType_ = "default";
400     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(LOCATION_BGMODE, LOCATION_BGMODE_ID, true, 1ULL), ERR_OK);
401     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BLUETOOTH_INTERACTION, LOCATION_BGMODE_ID, true, 1ULL),
402         ERR_BGTASK_INVALID_BGMODE);
403 }
404 
405 /**
406  * @tc.name: BgTaskManagerUnitTest_004
407  * @tc.desc: test GetBackgroundModeInfo.
408  * @tc.type: FUNC
409  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
410  */
411 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_004, TestSize.Level1)
412 {
413     bgContinuousTaskMgr_->cachedBundleInfos_.clear();
414     EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 0u);
415 
416     CachedBundleInfo info = CachedBundleInfo();
417     info.abilityBgMode_["abilityName"] = 1;
418     info.appName_ = "appName";
419     bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
420 
421     EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "test"), 0u);
422     EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 1u);
423     bgContinuousTaskMgr_->cachedBundleInfos_.clear();
424 }
425 
426 /**
427  * @tc.name: BgTaskManagerUnitTest_005
428  * @tc.desc: test SendContinuousTaskNotification.
429  * @tc.type: FUNC
430  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
431  */
432 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_005, TestSize.Level1)
433 {
434     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
435     continuousTaskRecord->bgModeId_ = 1;
436     continuousTaskRecord->bgModeIds_.clear();
437     continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
438     continuousTaskRecord->isNewApi_ = false;
439     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
440         ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
441     continuousTaskRecord->isNewApi_ = true;
442     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
443         ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
444     continuousTaskRecord->bgModeId_ = INVALID_BGMODE_ID;
445     continuousTaskRecord->bgModeIds_.clear();
446     continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
447     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
448         ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
449 
450     CachedBundleInfo info = CachedBundleInfo();
451     info.abilityBgMode_["abilityName"] = 1;
452     info.appName_ = "appName";
453     bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
454     continuousTaskRecord->uid_ = 1;
455     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
456         ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
457     continuousTaskRecord->bgModeId_ = 1;
458     continuousTaskRecord->bgModeIds_.clear();
459     continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
460     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
461 }
462 
463 /**
464  * @tc.name: BgTaskManagerUnitTest_006
465  * @tc.desc: test StopContinuousTask.
466  * @tc.type: FUNC
467  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
468  */
469 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_006, TestSize.Level1)
470 {
471     bgContinuousTaskMgr_->isSysReady_.store(false);
472     bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
473     bgContinuousTaskMgr_->isSysReady_.store(true);
474     bgContinuousTaskMgr_->StopContinuousTask(-1, 1, 1, "");
475     SleepForFC();
476     bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
477     SleepForFC();
478 
479     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
480     continuousTaskRecord1->uid_ = TEST_NUM_ONE;
481     continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
482     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
483     continuousTaskRecord2->uid_ = TEST_NUM_ONE;
484     continuousTaskRecord2->bgModeId_ = TEST_NUM_THREE;
485     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord3 = std::make_shared<ContinuousTaskRecord>();
486     continuousTaskRecord3->uid_ = TEST_NUM_TWO;
487     continuousTaskRecord3->bgModeId_ = TEST_NUM_TWO;
488     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord4 = std::make_shared<ContinuousTaskRecord>();
489     continuousTaskRecord4->uid_ = TEST_NUM_TWO;
490     continuousTaskRecord4->bgModeId_ = TEST_NUM_THREE;
491 
492     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
493     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
494     bgContinuousTaskMgr_->continuousTaskInfosMap_["key3"] = continuousTaskRecord3;
495     bgContinuousTaskMgr_->continuousTaskInfosMap_["key4"] = continuousTaskRecord4;
496     bgContinuousTaskMgr_->StopContinuousTask(-1, 1, 1, "");
497     SleepForFC();
498     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
499 
500     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
501     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
502     bgContinuousTaskMgr_->continuousTaskInfosMap_["key3"] = continuousTaskRecord3;
503     bgContinuousTaskMgr_->continuousTaskInfosMap_["key4"] = continuousTaskRecord4;
504     bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
505     SleepForFC();
506     EXPECT_TRUE(true);
507 }
508 
509 /**
510  * @tc.name: BgTaskManagerUnitTest_007
511  * @tc.desc: test GetContinuousTaskApps.
512  * @tc.type: FUNC
513  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
514  */
515 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_007, TestSize.Level1)
516 {
517     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
518     bgContinuousTaskMgr_->isSysReady_.store(false);
519     std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list;
520     EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_BGTASK_SYS_NOT_READY);
521     bgContinuousTaskMgr_->isSysReady_.store(true);
522     EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
523 
524 
525     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
526     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
527     EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
528 }
529 
530 /**
531  * @tc.name: BgTaskManagerUnitTest_008
532  * @tc.desc: test ShellDump.
533  * @tc.type: FUNC
534  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
535  */
536 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_008, TestSize.Level1)
537 {
538     bgContinuousTaskMgr_->isSysReady_.store(false);
539     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
540     std::vector<std::string> dumpOption;
541     dumpOption.emplace_back("-C");
542     std::vector<std::string> dumpInfo;
543     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_SYS_NOT_READY);
544     bgContinuousTaskMgr_->isSysReady_.store(true);
545     dumpOption.emplace_back("--all");
546     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
547     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
548     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
549     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
550     dumpOption.pop_back();
551     dumpOption.emplace_back("--cancel_all");
552     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
553     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
554     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
555     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
556     dumpOption.pop_back();
557     dumpOption.emplace_back("--cancel");
558     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
559     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
560     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
561     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
562     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
563     dumpOption.pop_back();
564     dumpOption.emplace_back("invalid");
565     EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
566 }
567 
568 /**
569  * @tc.name: BgTaskManagerUnitTest_009
570  * @tc.desc: test RemoveContinuousTaskRecord.
571  * @tc.type: FUNC
572  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
573  */
574 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_009, TestSize.Level1)
575 {
576     EXPECT_FALSE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
577     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
578     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
579     EXPECT_TRUE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
580 }
581 
582 /**
583  * @tc.name: BgTaskManagerUnitTest_010
584  * @tc.desc: test StopContinuousTaskByUser.
585  * @tc.type: FUNC
586  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
587  */
588 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_010, TestSize.Level1)
589 {
590     bgContinuousTaskMgr_->isSysReady_.store(false);
591     EXPECT_FALSE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
592     bgContinuousTaskMgr_->isSysReady_.store(true);
593     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
594     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
595     EXPECT_TRUE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
596 }
597 
598 /**
599  * @tc.name: BgTaskManagerUnitTest_011
600  * @tc.desc: test OnRemoteSubscriberDied.
601  * @tc.type: FUNC
602  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
603  */
604 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_011, TestSize.Level1)
605 {
606     bgContinuousTaskMgr_->isSysReady_.store(false);
607     bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
608     bgContinuousTaskMgr_->isSysReady_.store(true);
609     bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
610     TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
611     TestBackgroundTaskSubscriber subscriber2 = TestBackgroundTaskSubscriber();
612     bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(subscriber1.GetImpl());
613     bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(subscriber2.GetImpl());
614     bgContinuousTaskMgr_->OnRemoteSubscriberDied(subscriber1.GetImpl());
615     EXPECT_TRUE(true);
616 }
617 
618 /**
619  * @tc.name: BgTaskManagerUnitTest_012
620  * @tc.desc: test OnAbilityStateChanged.
621  * @tc.type: FUNC
622  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB
623  */
624 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_012, TestSize.Level1)
625 {
626     bgContinuousTaskMgr_->isSysReady_.store(false);
627     bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
628     bgContinuousTaskMgr_->isSysReady_.store(true);
629     bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
630 
631     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
632     bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
633     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
634     continuousTaskRecord->uid_ = 1;
635     continuousTaskRecord->abilityName_ = "test";
636     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
637     bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
638     bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test1", -1);
639     bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test1", -1);
640     bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test", -1);
641     EXPECT_TRUE(true);
642 }
643 
644 /**
645  * @tc.name: BgTaskManagerUnitTest_013
646  * @tc.desc: test OnAppStopped.
647  * @tc.type: FUNC
648  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueIALCBZ
649  */
650 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_013, TestSize.Level1)
651 {
652     bgContinuousTaskMgr_->isSysReady_.store(false);
653     bgContinuousTaskMgr_->OnAppStopped(1);
654     bgContinuousTaskMgr_->isSysReady_.store(true);
655     bgContinuousTaskMgr_->OnAppStopped(1);
656 
657     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
658     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
659     continuousTaskRecord->uid_ = 1;
660     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
661     bgContinuousTaskMgr_->OnAppStopped(-1);
662     bgContinuousTaskMgr_->OnAppStopped(1);
663     EXPECT_TRUE(true);
664 }
665 
666 /**
667  * @tc.name: BgTaskManagerUnitTest_014
668  * @tc.desc: test OnContinuousTaskChanged.
669  * @tc.type: FUNC
670  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
671  */
672 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_014, TestSize.Level1)
673 {
674     bgContinuousTaskMgr_->OnContinuousTaskChanged(nullptr, ContinuousTaskEventTriggerType::TASK_START);
675     bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
676     auto continuousTaskInfo =  std::make_shared<ContinuousTaskRecord>();
677     bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
678     TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
679     bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(subscriber.GetImpl());
680     bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
681     bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_UPDATE);
682     bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_CANCEL);
683     EXPECT_TRUE(true);
684 }
685 
686 /**
687  * @tc.name: BgTaskManagerUnitTest_015
688  * @tc.desc: test OnBundleInfoChanged.
689  * @tc.type: FUNC
690  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
691  */
692 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_015, TestSize.Level1)
693 {
694     bgContinuousTaskMgr_->isSysReady_.store(false);
695     bgContinuousTaskMgr_->OnBundleInfoChanged("action", "bundleName", -1);
696     bgContinuousTaskMgr_->isSysReady_.store(true);
697     bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED,
698         "bundleName", -1);
699 
700     bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
701         "bundleName", -1);
702 
703     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
704     bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
705     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
706     continuousTaskRecord1->uid_ = TEST_NUM_ONE;
707     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
708     continuousTaskRecord2->uid_ = TEST_NUM_TWO;
709     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
710     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
711     bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
712         "bundleName", 1);
713     EXPECT_TRUE(true);
714 }
715 
716 /**
717  * @tc.name: BgTaskManagerUnitTest_016
718  * @tc.desc: test OnAccountsStateChanged.
719  * @tc.type: FUNC
720  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
721  */
722 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_016, TestSize.Level1)
723 {
724     bgContinuousTaskMgr_->OnAccountsStateChanged(1);
725     bgContinuousTaskMgr_->OnAccountsStateChanged(1);
726 
727     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
728     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
729     continuousTaskRecord1->userId_ = 1;
730     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
731     continuousTaskRecord2->userId_ = DEFAULT_USERID;
732     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
733     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
734     bgContinuousTaskMgr_->OnAccountsStateChanged(1);
735     EXPECT_TRUE(true);
736 }
737 
738 /**
739  * @tc.name: BgTaskManagerUnitTest_017
740  * @tc.desc: test HandleAppContinuousTaskStop.
741  * @tc.type: FUNC
742  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
743  */
744 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_017, TestSize.Level1)
745 {
746     bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
747     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
748     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
749     continuousTaskRecord->uid_ = 1;
750     bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
751     bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
752     EXPECT_TRUE(true);
753 }
754 
755 /**
756  * @tc.name: BgTaskManagerUnitTest_033
757  * @tc.desc: test CheckPersistenceData.
758  * @tc.type: FUNC
759  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
760  */
761 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_033, TestSize.Level1)
762 {
763 #ifdef DISTRIBUTED_NOTIFICATION_ENABLE
764     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
765     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
766     continuousTaskRecord1->pid_ = TEST_NUM_ONE;
767     continuousTaskRecord1->notificationLabel_ = "label1";
768 
769     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
770     continuousTaskRecord2->pid_ = TEST_NUM_TWO;
771     continuousTaskRecord2->notificationLabel_ = "label1";
772     continuousTaskRecord2->notificationId_ = 100;
773 
774     std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
775     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
776     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
777     bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
778     EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
779 
780     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
781     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
782     AppExecFwk::RunningProcessInfo processInfo1;
783     processInfo1.pid_ = TEST_NUM_ONE;
784     AppExecFwk::RunningProcessInfo processInfo2;
785     processInfo2.pid_ = TEST_NUM_TWO;
786     allProcesses.push_back(processInfo1);
787     allProcesses.push_back(processInfo2);
788     bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
789     EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
790 #endif
791 }
792 
793 /**
794  * @tc.name: BgTaskManagerUnitTest_034
795  * @tc.desc: test HandleStopContinuousTask.
796  * @tc.type: FUNC
797  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
798  */
799 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_034, TestSize.Level1)
800 {
801     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
802     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
803     continuousTaskRecord1->uid_ = TEST_NUM_ONE;
804     continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
805     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
806     continuousTaskRecord1->uid_ = TEST_NUM_ONE;
807     continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
808 
809     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
810     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
811     bgContinuousTaskMgr_->HandleStopContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, TEST_NUM_ONE, "");
812     EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
813 }
814 
815 /**
816  * @tc.name: BgTaskManagerUnitTest_035
817  * @tc.desc: test HandleStopContinuousTask.
818  * @tc.type: FUNC
819  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
820  */
821 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_035, TestSize.Level1)
822 {
823     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
824     bgContinuousTaskMgr_->HandleStopContinuousTask(0, 0, 0, "");
825     EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
826 
827     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
828     continuousTaskRecord1->uid_ = 1;
829     continuousTaskRecord1->bgModeIds_ = {1};
830     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
831     EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
832 
833     bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 1, "");
834     EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
835 
836     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
837     EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
838     bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0xFF, "");
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, 0, "key1");
844     EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
845 }
846 
847 /**
848  * @tc.name: BgTaskManagerUnitTest_036
849  * @tc.desc: test SubscriberChange.
850  * @tc.type: FUNC
851  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
852  */
853 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_036, TestSize.Level1)
854 {
855     TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
856     bgContinuousTaskMgr_->AddSubscriberInner(subscriber1.GetImpl());
857     EXPECT_EQ(bgContinuousTaskMgr_->AddSubscriberInner(subscriber1.GetImpl()), ERR_BGTASK_OBJECT_EXISTS);
858     sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
859         = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
860     EXPECT_EQ(bgContinuousTaskMgr_->AddSubscriberInner(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
861 
862     bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
863     EXPECT_EQ(bgContinuousTaskMgr_->RemoveSubscriberInner(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
864     EXPECT_EQ(bgContinuousTaskMgr_->RemoveSubscriberInner(subscriber1.GetImpl()), ERR_BGTASK_INVALID_PARAM);
865 }
866 
867 /**
868  * @tc.name: BgTaskManagerUnitTest_037
869  * @tc.desc: test DumpAllTaskInfo.
870  * @tc.type: FUNC
871  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
872  */
873 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_037, TestSize.Level1)
874 {
875     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
876     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
877     continuousTaskRecord1->pid_ = TEST_NUM_ONE;
878     continuousTaskRecord1->notificationLabel_ = "label1";
879 
880     std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
881     info->bundleName_ = "wantAgentBundleName";
882     info->abilityName_ = "wantAgentAbilityName";
883     continuousTaskRecord1->wantAgentInfo_ = info;
884     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
885     std::vector<std::string> dumpInfo;
886     bgContinuousTaskMgr_->DumpAllTaskInfo(dumpInfo);
887     EXPECT_NE((int32_t)dumpInfo.size(), 0);
888 }
889 
890 /**
891  * @tc.name: BgTaskManagerUnitTest_038
892  * @tc.desc: test DumpCancelTask.
893  * @tc.type: FUNC
894  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
895  */
896 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_038, TestSize.Level1)
897 {
898     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
899     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
900     continuousTaskRecord1->pid_ = TEST_NUM_ONE;
901     continuousTaskRecord1->notificationLabel_ = "label1";
902 
903     std::vector<std::string> dumpOption;
904     dumpOption.emplace_back("param1");
905     dumpOption.emplace_back("param2");
906     dumpOption.emplace_back("key1");
907 
908     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
909     bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
910     dumpOption.pop_back();
911     dumpOption.emplace_back("key2");
912     bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
913     EXPECT_NE((int32_t)dumpOption.size(), 0);
914 }
915 
916 /**
917  * @tc.name: BgTaskManagerUnitTest_039
918  * @tc.desc: test OnConfigurationChanged.
919  * @tc.type: FUNC
920  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
921  */
922 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_039, TestSize.Level1)
923 {
924     AppExecFwk::Configuration configuration;
925     bgContinuousTaskMgr_->isSysReady_.store(false);
926     bgContinuousTaskMgr_->OnConfigurationChanged(configuration);
927     bgContinuousTaskMgr_->isSysReady_.store(true);
928 
929     bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
930     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
931     continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
932     continuousTaskRecord1->isNewApi_ = true;
933 
934     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
935     continuousTaskRecord2->bgModeId_ = INVALID_BGMODE_ID;
936     continuousTaskRecord1->isNewApi_ = true;
937 
938     bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
939     bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
940     EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
941 }
942 
943 /**
944  * @tc.name: BgTaskManagerUnitTest_043
945  * @tc.desc: test RequestBackgroundRunningForInner.
946  * @tc.type: FUNC
947  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
948  */
949 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_043, TestSize.Level1)
950 {
951     bgContinuousTaskMgr_->isSysReady_.store(false);
952     EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_SYS_NOT_READY);
953     bgContinuousTaskMgr_->isSysReady_.store(true);
954     EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_CHECK_TASK_PARAM);
955     sptr<ContinuousTaskParamForInner> taskParam = sptr<ContinuousTaskParamForInner>(
956         new ContinuousTaskParamForInner(1, 1, true));
957     EXPECT_EQ(bgContinuousTaskMgr_->StartBackgroundRunningForInner(taskParam), ERR_OK);
958     taskParam->isStart_ = false;
959     EXPECT_EQ(bgContinuousTaskMgr_->StopBackgroundRunningForInner(taskParam), ERR_OK);
960 }
961 
962 /**
963  * @tc.name: BgTaskManagerUnitTest_044
964  * @tc.desc: test CheckBgmodeTypeForInner.
965  * @tc.type: FUNC
966  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
967  */
968 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_044, TestSize.Level1)
969 {
970     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(0), ERR_BGTASK_INVALID_BGMODE);
971     EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(1), ERR_OK);
972 }
973 
974 /**
975  * @tc.name: BgTaskManagerUnitTest_045
976  * @tc.desc: test CheckProcessUidInfo.
977  * @tc.type: FUNC
978  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
979  */
980 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_045, TestSize.Level1)
981 {
982     std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
983 
984     AppExecFwk::RunningProcessInfo info1;
985     info1.uid_ = TEST_NUM_ONE;
986     allProcesses.push_back(info1);
987     EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), false);
988     AppExecFwk::RunningProcessInfo info2;
989     info2.uid_ = TEST_NUM_TWO;
990     allProcesses.push_back(info2);
991     EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), true);
992 }
993 
994 /**
995  * @tc.name: BgTaskManagerUnitTest_046
996  * @tc.desc: test SendContinuousTaskNotification.
997  * @tc.type: FUNC
998  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
999  */
1000 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_046, TestSize.Level1)
1001 {
1002     std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1003     continuousTaskRecord->bgModeId_ = 2;
1004     continuousTaskRecord->isNewApi_ = true;
1005     continuousTaskRecord->uid_ = 1;
1006 
1007     CachedBundleInfo info = CachedBundleInfo();
1008     info.abilityBgMode_["abilityName"] = 2;
1009     info.appName_ = "appName";
1010     bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
1011 
1012     EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
1013 }
1014 }  // namespace BackgroundTaskMgr
1015 }  // namespace OHOS