1 /*
2 * Copyright (c) 2022-2025 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 int32_t DEFAULT_USERID = 100;
48 static constexpr int32_t TEST_NUM_ONE = 1;
49 static constexpr int32_t TEST_NUM_TWO = 2;
50 static constexpr int32_t TEST_NUM_THREE = 3;
51 static constexpr uint32_t CONFIGURE_ALL_MODES = 0x1FF;
52 static constexpr char BG_TASK_SUB_MODE_TYPE[] = "subMode";
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 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskSubText_), PROMPT_NUMS, "bgmsubmode_test");
75 bgContinuousTaskMgr_->isSysReady_.store(true);
76 }
77
TearDownTestCase()78 void BgContinuousTaskMgrTest::TearDownTestCase() {}
79
SetUp()80 void BgContinuousTaskMgrTest::SetUp() {}
81
TearDown()82 void BgContinuousTaskMgrTest::TearDown()
83 {
84 std::vector<string> dumpOption;
85 dumpOption.emplace_back("-C");
86 dumpOption.emplace_back("--cancel_all");
87 std::vector<string> dumpInfo;
88 bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo);
89 }
90
91 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {
92 public:
OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)93 void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo>
94 &continuousTaskCallbackInfo) override {}
95
OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)96 void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo>
97 &continuousTaskCallbackInfo) override {}
98 };
99
100 /**
101 * @tc.name: StartBackgroundRunning_001
102 * @tc.desc: start background runnging use new api test.
103 * @tc.type: FUNC
104 * @tc.require: SR000GGT7U AR000GH6ER AR000GH6EM AR000GH6EN AR000GH6EO
105 */
106 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_001, TestSize.Level1)
107 {
108 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
109 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
110 EXPECT_NE(taskParam, nullptr);
111 taskParam->appName_ = "Entry";
112 taskParam->isNewApi_ = true;
113 taskParam->abilityId_ = 1;
114 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
115 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
116 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
117 taskParam->abilityName_ = "";
118 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
119 taskParam->abilityName_ = "ability1";
120 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
121 taskParam->bgModeId_ = 9;
122 taskParam->bgModeIds_.clear();
123 EXPECT_NE((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), -1);
124 taskParam->bgModeId_ = 1;
125 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
126 taskParam->bgModeId_ = 4;
127 CachedBundleInfo info = CachedBundleInfo();
128 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
129 info.appName_ = "Entry";
130 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
131 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
132 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
133 }
134
135 /**
136 * @tc.name: StartBackgroundRunning_002
137 * @tc.desc: start background runnging use old api test.
138 * @tc.type: FUNC
139 * @tc.require: SR000GGT7T AR000GH6ER AR000GH6EP AR000GJ9PR AR000GH6G8
140 */
141 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_002, TestSize.Level1)
142 {
143 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
144 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
145 EXPECT_NE(taskParam, nullptr);
146 taskParam->appName_ = "Entry";
147 taskParam->isNewApi_ = false;
148 taskParam->bgModeId_ = 0;
149 taskParam->abilityName_ = "";
150 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
151 taskParam->abilityName_ = "ability1";
152 CachedBundleInfo info = CachedBundleInfo();
153 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
154 info.appName_ = "Entry";
155 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
156 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
157 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
158 }
159
160 /**
161 * @tc.name: StartBackgroundRunning_003
162 * @tc.desc: start background runnging by abilityIds test.
163 * @tc.type: FUNC
164 * @tc.require: issueI99HSB
165 */
166 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_003, TestSize.Level1)
167 {
168 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
169 int taskSize = 0;
170 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
171 CachedBundleInfo info = CachedBundleInfo();
172 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
173 info.appName_ = "Entry";
174 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
175
176 // start one task by abilityId is 1
177 sptr<ContinuousTaskParam> taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 0,
178 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
179 "ability1", nullptr, "Entry", true, {1, 2, 3}, 1);
180 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam1), (int32_t)ERR_OK);
181
182 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
183 EXPECT_EQ(taskSize, 1);
184
185 int32_t abilityId = -1;
186 std::unordered_map<std::string, std::shared_ptr<ContinuousTaskRecord>>::iterator iter;
187 for (iter = bgContinuousTaskMgr_->continuousTaskInfosMap_.begin();
188 iter != bgContinuousTaskMgr_->continuousTaskInfosMap_.end(); ++iter) {
189 abilityId = iter->second->GetAbilityId();
190 }
191 EXPECT_EQ(abilityId, 1);
192
193 // start one task by abilityId is 2
194 sptr<ContinuousTaskParam> taskParam2 = new (std::nothrow) ContinuousTaskParam(true, 0,
195 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
196 "ability1", nullptr, "Entry", true, {1, 2, 3}, 2);
197 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam2), (int32_t)ERR_OK);
198
199 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
200 EXPECT_EQ(taskSize, 2);
201
202 // agent start one task by abilityId is 2
203 sptr<ContinuousTaskParam> taskParam3 = new (std::nothrow) ContinuousTaskParam(true, 0,
204 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
205 "ability1", nullptr, "Entry", true, {1, 2, 3}, 2);
206 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam3),
207 (int32_t)ERR_BGTASK_OBJECT_EXISTS);
208
209 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
210 EXPECT_EQ(taskSize, 2);
211
212 // stop one task by abilityId is 1
213 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam1->abilityName_, 1), (int32_t)ERR_OK);
214
215 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
216 EXPECT_EQ(taskSize, 1);
217
218 // stop one task by abilityId is 2
219 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 2), (int32_t)ERR_OK);
220
221 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
222 EXPECT_EQ(taskSize, 0);
223
224 // agent stop one task by abilityId is 2
225 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 2),
226 (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
227
228 taskSize = bgContinuousTaskMgr_->continuousTaskInfosMap_.size();
229 EXPECT_EQ(taskSize, 0);
230 }
231
232 /**
233 * @tc.name: StartAndUpdateBackgroundRunning_001
234 * @tc.desc: use batch api.
235 * @tc.type: FUNC
236 * @tc.require: issueI94UH9 issueI99HSB
237 */
238 HWTEST_F(BgContinuousTaskMgrTest, StartAndUpdateBackgroundRunning_001, TestSize.Level1)
239 {
240 // 1 modes is empty
241 sptr<ContinuousTaskParam> taskParam1 = new (std::nothrow) ContinuousTaskParam(true, 0,
242 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
243 "ability1", nullptr, "Entry", true, {});
244 EXPECT_NE(taskParam1, nullptr);
245 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam1), (int32_t)ERR_BGTASK_INVALID_BGMODE);
246
247 // 2 set configure mode is CONFIGURE_ALL_MODES
248 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
249 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 0u);
250 CachedBundleInfo info = CachedBundleInfo();
251 info.abilityBgMode_["ability1"] = CONFIGURE_ALL_MODES;
252 info.appName_ = "Entry";
253 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
254
255 // 3 start ok
256 sptr<ContinuousTaskParam> taskParam2 = new (std::nothrow) ContinuousTaskParam(true, 0,
257 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
258 "ability1", nullptr, "Entry", true, {1, 2, 3}, 1);
259 EXPECT_NE(taskParam2, nullptr);
260 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam2), (int32_t)ERR_OK);
261
262 // 4 update ok
263 sptr<ContinuousTaskParam> taskParam3 = new (std::nothrow) ContinuousTaskParam(true, 0,
264 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
265 "ability1", nullptr, "Entry", true, {4}, 1);
266 EXPECT_NE(taskParam3, nullptr);
267 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam3), (int32_t)ERR_OK);
268
269 // 5 update invalid
270 sptr<ContinuousTaskParam> taskParam4 = new (std::nothrow) ContinuousTaskParam(true, 0,
271 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
272 "ability1", nullptr, "Entry", true, {10}, 1);
273 EXPECT_NE(taskParam4, nullptr);
274 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam4), (int32_t)ERR_BGTASK_INVALID_BGMODE);
275
276 // 6 stop ok
277 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(taskParam2->abilityName_, 1), (int32_t)ERR_OK);
278
279 // 7 no start then update error
280 sptr<ContinuousTaskParam> taskParam5 = new (std::nothrow) ContinuousTaskParam(true, 0,
281 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(),
282 "ability1", nullptr, "Entry", true, {1, 2});
283 EXPECT_NE(taskParam5, nullptr);
284 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->UpdateBackgroundRunning(taskParam5), (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
285 }
286
287 /**
288 * @tc.name: StopBackgroundRunning_001
289 * @tc.desc: stop background runnging test.
290 * @tc.type: FUNC
291 * @tc.require: SR000GGT7V AR000GH6ES AR000GH6EM AR000GH6G9 AR000GH56K issueI99HSB
292 */
293 HWTEST_F(BgContinuousTaskMgrTest, StopBackgroundRunning_001, TestSize.Level1)
294 {
295 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
296 EXPECT_NE(taskParam, nullptr);
297 taskParam->appName_ = "Entry";
298 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
299 taskParam->abilityName_ = "ability1";
300 taskParam->bgModeId_ = 4;
301 taskParam->abilityId_ = 1;
302 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("", 1), (int32_t)ERR_BGTASK_INVALID_PARAM);
303 SleepForFC();
304 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1),
305 (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
306 SleepForFC();
307 bgContinuousTaskMgr_->StartBackgroundRunning(taskParam);
308 SleepForFC();
309 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1), (int32_t)ERR_OK);
310 }
311
312 /**
313 * @tc.name: StopBackgroundRunning_002
314 * @tc.desc: stop background runnging test.
315 * @tc.type: FUNC
316 * @tc.require: issues#I8FWJH issueI99HSB
317 */
318 HWTEST_F(BgContinuousTaskMgrTest, StopBackgroundRunning_002, TestSize.Level1)
319 {
320 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
321 EXPECT_NE(taskParam, nullptr);
322 taskParam->appName_ = "Entry";
323 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
324 taskParam->abilityName_ = "ability1";
325 taskParam->bgModeId_ = 2;
326 taskParam->abilityId_ = 1;
327 bgContinuousTaskMgr_->StartBackgroundRunning(taskParam);
328 SleepForFC();
329 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1", 1), (int32_t)ERR_OK);
330 }
331
332 /**
333 * @tc.name: SubscribeContinuousTask_001
334 * @tc.desc: subscribe continuous task event callback test.
335 * @tc.type: FUNC
336 * @tc.require: SR000GGT81 AR000GH6EM AR000GH6G9 AR000GH6ET
337 */
338 HWTEST_F(BgContinuousTaskMgrTest, SubscribeContinuousTask_001, TestSize.Level1)
339 {
340 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(nullptr), (int32_t)ERR_BGTASK_INVALID_PARAM);
341 SleepForFC();
342 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
343 EXPECT_NE(subscriber, nullptr);
344 auto info = std::make_shared<SubscriberInfo>(subscriber->GetImpl(), 1, 1, 0, 0);
345 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(info), (int32_t)ERR_OK);
346 }
347
348 /**
349 * @tc.name: UnsubscribeContinuousTask_001
350 * @tc.desc: unsubscribe continuous task event callback test.
351 * @tc.type: FUNC
352 * @tc.require: SR000GGT7U AR000GH6EM AR000GH6G9 AR000GH6ET
353 */
354 HWTEST_F(BgContinuousTaskMgrTest, UnsubscribeContinuousTask_001, TestSize.Level1)
355 {
356 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
357 EXPECT_NE(subscriber, nullptr);
358 auto info = std::make_shared<SubscriberInfo>(subscriber->GetImpl(), 1, 1, 0, 0);
359 bgContinuousTaskMgr_->AddSubscriber(info);
360 SleepForFC();
361 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->RemoveSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
362 }
363
364 /**
365 * @tc.name: BgTaskManagerUnitTest_002
366 * @tc.desc: test SetCachedBundleInfo.
367 * @tc.type: FUNC
368 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
369 */
370 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_002, TestSize.Level1)
371 {
372 EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "false-test", "test"));
373 EXPECT_FALSE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "empty-info", "test"));
374 EXPECT_TRUE(bgContinuousTaskMgr_->SetCachedBundleInfo(1, 1, "valid", "test"));
375 }
376
377 /**
378 * @tc.name: BgTaskManagerUnitTest_003
379 * @tc.desc: test CheckBgmodeType.
380 * @tc.type: FUNC
381 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
382 */
383 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_003, TestSize.Level1)
384 {
385 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
386 continuousTaskRecord->bundleName_ = "bundleName";
387 continuousTaskRecord->isNewApi_ = false;
388 continuousTaskRecord->isSystem_ = true;
389 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(0, 1, false, continuousTaskRecord), ERR_BGMODE_NULL_OR_TYPE_ERR);
390 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(1, 1, false, continuousTaskRecord), ERR_OK);
391 continuousTaskRecord->isSystem_ = false;
392 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
393 true, continuousTaskRecord), ERR_BGTASK_NOT_SYSTEM_APP);
394 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, continuousTaskRecord), ERR_OK);
395 continuousTaskRecord->isSystem_ = true;
396 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_WIFI_INTERACTION, BGMODE_WIFI_INTERACTION_ID,
397 true, continuousTaskRecord), ERR_OK);
398 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, continuousTaskRecord), ERR_OK);
399 if (SUPPORT_TASK_KEEPING) {
400 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true,
401 continuousTaskRecord), ERR_OK);
402 } else {
403 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(PC_BGMODE_TASK_KEEPING, BGMODE_TASK_KEEPING_ID, true,
404 continuousTaskRecord), ERR_BGTASK_KEEPING_TASK_VERIFY_ERR);
405 }
406 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BGMODE_VOIP, BGMODE_VOIP_ID, true, continuousTaskRecord), ERR_OK);
407 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(LOCATION_BGMODE, LOCATION_BGMODE_ID, true, continuousTaskRecord),
408 ERR_OK);
409 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeType(BLUETOOTH_INTERACTION, LOCATION_BGMODE_ID, true,
410 continuousTaskRecord), ERR_BGTASK_INVALID_BGMODE);
411 }
412
413 /**
414 * @tc.name: BgTaskManagerUnitTest_004
415 * @tc.desc: test GetBackgroundModeInfo.
416 * @tc.type: FUNC
417 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
418 */
419 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_004, TestSize.Level1)
420 {
421 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
422 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 0u);
423
424 CachedBundleInfo info = CachedBundleInfo();
425 info.abilityBgMode_["abilityName"] = 1;
426 info.appName_ = "appName";
427 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
428
429 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "test"), 0u);
430 EXPECT_EQ(bgContinuousTaskMgr_->GetBackgroundModeInfo(1, "abilityName"), 1u);
431 bgContinuousTaskMgr_->cachedBundleInfos_.clear();
432 }
433
434 /**
435 * @tc.name: BgTaskManagerUnitTest_005
436 * @tc.desc: test SendContinuousTaskNotification.
437 * @tc.type: FUNC
438 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
439 */
440 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_005, TestSize.Level1)
441 {
442 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
443 continuousTaskRecord->bgModeId_ = 1;
444 continuousTaskRecord->bgModeIds_.clear();
445 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
446 continuousTaskRecord->isNewApi_ = false;
447 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
448 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
449 continuousTaskRecord->isNewApi_ = true;
450 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
451 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
452 continuousTaskRecord->bgModeId_ = INVALID_BGMODE_ID;
453 continuousTaskRecord->bgModeIds_.clear();
454 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
455 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
456 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
457
458 CachedBundleInfo info = CachedBundleInfo();
459 info.abilityBgMode_["abilityName"] = 1;
460 info.appName_ = "appName";
461 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
462 continuousTaskRecord->uid_ = 1;
463 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord),
464 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
465 continuousTaskRecord->bgModeId_ = 1;
466 continuousTaskRecord->bgModeIds_.clear();
467 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
468 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
469 }
470
471 /**
472 * @tc.name: BgTaskManagerUnitTest_006
473 * @tc.desc: test StopContinuousTask.
474 * @tc.type: FUNC
475 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
476 */
477 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_006, TestSize.Level1)
478 {
479 bgContinuousTaskMgr_->isSysReady_.store(false);
480 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
481 bgContinuousTaskMgr_->isSysReady_.store(true);
482 bgContinuousTaskMgr_->StopContinuousTask(-1, 1, 1, "");
483 SleepForFC();
484 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
485 SleepForFC();
486
487 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
488 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
489 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
490 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
491 continuousTaskRecord2->uid_ = TEST_NUM_ONE;
492 continuousTaskRecord2->bgModeId_ = TEST_NUM_THREE;
493 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord3 = std::make_shared<ContinuousTaskRecord>();
494 continuousTaskRecord3->uid_ = TEST_NUM_TWO;
495 continuousTaskRecord3->bgModeId_ = TEST_NUM_TWO;
496 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord4 = std::make_shared<ContinuousTaskRecord>();
497 continuousTaskRecord4->uid_ = TEST_NUM_TWO;
498 continuousTaskRecord4->bgModeId_ = TEST_NUM_THREE;
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 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
507
508 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
509 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
510 bgContinuousTaskMgr_->continuousTaskInfosMap_["key3"] = continuousTaskRecord3;
511 bgContinuousTaskMgr_->continuousTaskInfosMap_["key4"] = continuousTaskRecord4;
512 bgContinuousTaskMgr_->StopContinuousTask(1, 1, 1, "");
513 SleepForFC();
514 EXPECT_TRUE(true);
515 }
516
517 /**
518 * @tc.name: BgTaskManagerUnitTest_007
519 * @tc.desc: test GetContinuousTaskApps.
520 * @tc.type: FUNC
521 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
522 */
523 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_007, TestSize.Level1)
524 {
525 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
526 bgContinuousTaskMgr_->isSysReady_.store(false);
527 std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list;
528 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_BGTASK_SYS_NOT_READY);
529 bgContinuousTaskMgr_->isSysReady_.store(true);
530 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
531
532
533 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
534 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
535 EXPECT_EQ(bgContinuousTaskMgr_->GetContinuousTaskApps(list), ERR_OK);
536 }
537
538 /**
539 * @tc.name: BgTaskManagerUnitTest_008
540 * @tc.desc: test ShellDump.
541 * @tc.type: FUNC
542 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
543 */
544 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_008, TestSize.Level1)
545 {
546 bgContinuousTaskMgr_->isSysReady_.store(false);
547 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
548 std::vector<std::string> dumpOption;
549 dumpOption.emplace_back("-C");
550 std::vector<std::string> dumpInfo;
551 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_SYS_NOT_READY);
552 bgContinuousTaskMgr_->isSysReady_.store(true);
553 dumpOption.emplace_back("--all");
554 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
555 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
556 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
557 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
558 dumpOption.pop_back();
559 dumpOption.emplace_back("--cancel_all");
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 dumpOption.pop_back();
565 dumpOption.emplace_back("--cancel");
566 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
567 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
568 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
569 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
570 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
571 dumpOption.pop_back();
572 dumpOption.emplace_back("invalid");
573 EXPECT_EQ(bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
574 }
575
576 /**
577 * @tc.name: BgTaskManagerUnitTest_009
578 * @tc.desc: test RemoveContinuousTaskRecord.
579 * @tc.type: FUNC
580 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
581 */
582 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_009, TestSize.Level1)
583 {
584 EXPECT_FALSE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
585 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
586 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
587 EXPECT_TRUE(bgContinuousTaskMgr_->RemoveContinuousTaskRecord("key"));
588 }
589
590 /**
591 * @tc.name: BgTaskManagerUnitTest_010
592 * @tc.desc: test StopContinuousTaskByUser.
593 * @tc.type: FUNC
594 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
595 */
596 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_010, TestSize.Level1)
597 {
598 bgContinuousTaskMgr_->isSysReady_.store(false);
599 EXPECT_FALSE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
600 bgContinuousTaskMgr_->isSysReady_.store(true);
601 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
602 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
603 EXPECT_TRUE(bgContinuousTaskMgr_->StopContinuousTaskByUser("key"));
604 }
605
606 /**
607 * @tc.name: BgTaskManagerUnitTest_011
608 * @tc.desc: test OnRemoteSubscriberDied.
609 * @tc.type: FUNC
610 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
611 */
612 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_011, TestSize.Level1)
613 {
614 bgContinuousTaskMgr_->isSysReady_.store(false);
615 bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
616 bgContinuousTaskMgr_->isSysReady_.store(true);
617 bgContinuousTaskMgr_->OnRemoteSubscriberDied(nullptr);
618 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
619 auto info1 = std::make_shared<SubscriberInfo>(subscriber1.GetImpl(), 1, 1, 0, 0);
620 TestBackgroundTaskSubscriber subscriber2 = TestBackgroundTaskSubscriber();
621 auto info2 = std::make_shared<SubscriberInfo>(subscriber2.GetImpl(), 1, 1, 0, 0);
622 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info1);
623 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info2);
624 bgContinuousTaskMgr_->OnRemoteSubscriberDied(subscriber1.GetImpl());
625 EXPECT_TRUE(true);
626 }
627
628 /**
629 * @tc.name: BgTaskManagerUnitTest_012
630 * @tc.desc: test OnAbilityStateChanged.
631 * @tc.type: FUNC
632 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB
633 */
634 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_012, TestSize.Level1)
635 {
636 bgContinuousTaskMgr_->isSysReady_.store(false);
637 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
638 bgContinuousTaskMgr_->isSysReady_.store(true);
639 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
640
641 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
642 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
643 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
644 continuousTaskRecord->uid_ = 1;
645 continuousTaskRecord->abilityName_ = "test";
646 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
647 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test", -1);
648 bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test1", -1);
649 bgContinuousTaskMgr_->OnAbilityStateChanged(-1, "test1", -1);
650 bgContinuousTaskMgr_->OnAbilityStateChanged(1, "test", -1);
651 EXPECT_TRUE(true);
652 }
653
654 /**
655 * @tc.name: BgTaskManagerUnitTest_013
656 * @tc.desc: test OnAppStopped.
657 * @tc.type: FUNC
658 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V issueIALCBZ
659 */
660 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_013, TestSize.Level1)
661 {
662 bgContinuousTaskMgr_->isSysReady_.store(false);
663 bgContinuousTaskMgr_->OnAppStopped(1);
664 bgContinuousTaskMgr_->isSysReady_.store(true);
665 bgContinuousTaskMgr_->OnAppStopped(1);
666
667 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
668 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
669 continuousTaskRecord->uid_ = 1;
670 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
671 bgContinuousTaskMgr_->OnAppStopped(-1);
672 bgContinuousTaskMgr_->OnAppStopped(1);
673 EXPECT_TRUE(true);
674 }
675
676 /**
677 * @tc.name: BgTaskManagerUnitTest_014
678 * @tc.desc: test OnContinuousTaskChanged.
679 * @tc.type: FUNC
680 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
681 */
682 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_014, TestSize.Level1)
683 {
684 bgContinuousTaskMgr_->OnContinuousTaskChanged(nullptr, ContinuousTaskEventTriggerType::TASK_START);
685 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
686 auto continuousTaskInfo = std::make_shared<ContinuousTaskRecord>();
687 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
688 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
689 auto info = std::make_shared<SubscriberInfo>(subscriber.GetImpl(), 1, 1, 0, 0);
690 bgContinuousTaskMgr_->bgTaskSubscribers_.emplace_back(info);
691 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_START);
692 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_UPDATE);
693 bgContinuousTaskMgr_->OnContinuousTaskChanged(continuousTaskInfo, ContinuousTaskEventTriggerType::TASK_CANCEL);
694 EXPECT_TRUE(true);
695 }
696
697 /**
698 * @tc.name: BgTaskManagerUnitTest_015
699 * @tc.desc: test OnBundleInfoChanged.
700 * @tc.type: FUNC
701 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
702 */
703 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_015, TestSize.Level1)
704 {
705 bgContinuousTaskMgr_->isSysReady_.store(false);
706 bgContinuousTaskMgr_->OnBundleInfoChanged("action", "bundleName", -1);
707 bgContinuousTaskMgr_->isSysReady_.store(true);
708 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED,
709 "bundleName", -1);
710
711 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
712 "bundleName", -1);
713
714 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
715 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
716 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
717 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
718 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
719 continuousTaskRecord2->uid_ = TEST_NUM_TWO;
720 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
721 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
722 bgContinuousTaskMgr_->OnBundleInfoChanged(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED,
723 "bundleName", 1);
724 EXPECT_TRUE(true);
725 }
726
727 /**
728 * @tc.name: BgTaskManagerUnitTest_016
729 * @tc.desc: test OnAccountsStateChanged.
730 * @tc.type: FUNC
731 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
732 */
733 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_016, TestSize.Level1)
734 {
735 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
736 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
737
738 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
739 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
740 continuousTaskRecord1->userId_ = 1;
741 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
742 continuousTaskRecord2->userId_ = DEFAULT_USERID;
743 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
744 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
745 bgContinuousTaskMgr_->OnAccountsStateChanged(1);
746 EXPECT_TRUE(true);
747 }
748
749 /**
750 * @tc.name: BgTaskManagerUnitTest_017
751 * @tc.desc: test HandleAppContinuousTaskStop.
752 * @tc.type: FUNC
753 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
754 */
755 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_017, TestSize.Level1)
756 {
757 bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
758 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
759 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
760 continuousTaskRecord->uid_ = 1;
761 bgContinuousTaskMgr_->continuousTaskInfosMap_["key"] = continuousTaskRecord;
762 bgContinuousTaskMgr_->HandleAppContinuousTaskStop(1);
763 EXPECT_TRUE(true);
764 }
765
766 /**
767 * @tc.name: BgTaskManagerUnitTest_033
768 * @tc.desc: test CheckPersistenceData.
769 * @tc.type: FUNC
770 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
771 */
772 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_033, TestSize.Level1)
773 {
774 #ifdef DISTRIBUTED_NOTIFICATION_ENABLE
775 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
776 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
777 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
778 continuousTaskRecord1->notificationLabel_ = "label1";
779
780 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
781 continuousTaskRecord2->pid_ = TEST_NUM_TWO;
782 continuousTaskRecord2->notificationLabel_ = "label1";
783 continuousTaskRecord2->notificationId_ = 100;
784
785 std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
786 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
787 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
788 bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
789 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
790
791 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
792 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
793 AppExecFwk::RunningProcessInfo processInfo1;
794 processInfo1.pid_ = TEST_NUM_ONE;
795 AppExecFwk::RunningProcessInfo processInfo2;
796 processInfo2.pid_ = TEST_NUM_TWO;
797 allProcesses.push_back(processInfo1);
798 allProcesses.push_back(processInfo2);
799 bgContinuousTaskMgr_->CheckPersistenceData(allProcesses);
800 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
801 #endif
802 }
803
804 /**
805 * @tc.name: BgTaskManagerUnitTest_034
806 * @tc.desc: test HandleStopContinuousTask.
807 * @tc.type: FUNC
808 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
809 */
810 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_034, TestSize.Level1)
811 {
812 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
813 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
814 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
815 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
816 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
817 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
818 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
819
820 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
821 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
822 bgContinuousTaskMgr_->HandleStopContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, TEST_NUM_ONE, "");
823 EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
824 }
825
826 /**
827 * @tc.name: BgTaskManagerUnitTest_035
828 * @tc.desc: test HandleStopContinuousTask.
829 * @tc.type: FUNC
830 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
831 */
832 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_035, TestSize.Level1)
833 {
834 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
835 bgContinuousTaskMgr_->HandleStopContinuousTask(0, 0, 0, "");
836 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
837
838 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
839 continuousTaskRecord1->uid_ = 1;
840 continuousTaskRecord1->bgModeIds_ = {1};
841 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
842 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
843
844 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 1, "");
845 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
846
847 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
848 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
849 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0xFF, "");
850 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
851
852 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
853 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 1);
854 bgContinuousTaskMgr_->HandleStopContinuousTask(1, 0, 0, "key1");
855 EXPECT_EQ(bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
856 }
857
858 /**
859 * @tc.name: BgTaskManagerUnitTest_036
860 * @tc.desc: test SubscriberChange.
861 * @tc.type: FUNC
862 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
863 */
864 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_036, TestSize.Level1)
865 {
866 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
867 auto info = std::make_shared<SubscriberInfo>(subscriber1.GetImpl(), 1, 1, 0, 0);
868 bgContinuousTaskMgr_->AddSubscriberInner(info);
869 EXPECT_EQ(bgContinuousTaskMgr_->AddSubscriberInner(info), ERR_BGTASK_OBJECT_EXISTS);
870 bgContinuousTaskMgr_->bgTaskSubscribers_.clear();
871 EXPECT_EQ(bgContinuousTaskMgr_->RemoveSubscriberInner(subscriber1.GetImpl()), ERR_BGTASK_INVALID_PARAM);
872 }
873
874 /**
875 * @tc.name: BgTaskManagerUnitTest_037
876 * @tc.desc: test DumpAllTaskInfo.
877 * @tc.type: FUNC
878 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
879 */
880 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_037, TestSize.Level1)
881 {
882 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
883 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
884 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
885 continuousTaskRecord1->notificationLabel_ = "label1";
886
887 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
888 info->bundleName_ = "wantAgentBundleName";
889 info->abilityName_ = "wantAgentAbilityName";
890 continuousTaskRecord1->wantAgentInfo_ = info;
891 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
892 std::vector<std::string> dumpInfo;
893 bgContinuousTaskMgr_->DumpAllTaskInfo(dumpInfo);
894 EXPECT_NE((int32_t)dumpInfo.size(), 0);
895 }
896
897 /**
898 * @tc.name: BgTaskManagerUnitTest_038
899 * @tc.desc: test DumpCancelTask.
900 * @tc.type: FUNC
901 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
902 */
903 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_038, TestSize.Level1)
904 {
905 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
906 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
907 continuousTaskRecord1->pid_ = TEST_NUM_ONE;
908 continuousTaskRecord1->notificationLabel_ = "label1";
909
910 std::vector<std::string> dumpOption;
911 dumpOption.emplace_back("param1");
912 dumpOption.emplace_back("param2");
913 dumpOption.emplace_back("key1");
914
915 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
916 bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
917 dumpOption.pop_back();
918 dumpOption.emplace_back("key2");
919 bgContinuousTaskMgr_->DumpCancelTask(dumpOption, false);
920 EXPECT_NE((int32_t)dumpOption.size(), 0);
921 }
922
923 /**
924 * @tc.name: BgTaskManagerUnitTest_039
925 * @tc.desc: test OnConfigurationChanged.
926 * @tc.type: FUNC
927 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
928 */
929 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_039, TestSize.Level1)
930 {
931 AppExecFwk::Configuration configuration;
932 bgContinuousTaskMgr_->isSysReady_.store(false);
933 bgContinuousTaskMgr_->OnConfigurationChanged(configuration);
934 bgContinuousTaskMgr_->isSysReady_.store(true);
935
936 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
937 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
938 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
939 continuousTaskRecord1->isNewApi_ = true;
940
941 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
942 continuousTaskRecord2->bgModeId_ = INVALID_BGMODE_ID;
943 continuousTaskRecord1->isNewApi_ = true;
944
945 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
946 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
947 EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
948 }
949
950 /**
951 * @tc.name: BgTaskManagerUnitTest_043
952 * @tc.desc: test RequestBackgroundRunningForInner.
953 * @tc.type: FUNC
954 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
955 */
956 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_043, TestSize.Level1)
957 {
958 bgContinuousTaskMgr_->isSysReady_.store(false);
959 EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_SYS_NOT_READY);
960 bgContinuousTaskMgr_->isSysReady_.store(true);
961 EXPECT_EQ(bgContinuousTaskMgr_->RequestBackgroundRunningForInner(nullptr), ERR_BGTASK_CHECK_TASK_PARAM);
962 sptr<ContinuousTaskParamForInner> taskParam = sptr<ContinuousTaskParamForInner>(
963 new ContinuousTaskParamForInner(1, 1, true));
964 EXPECT_EQ(bgContinuousTaskMgr_->StartBackgroundRunningForInner(taskParam), ERR_OK);
965 taskParam->isStart_ = false;
966 EXPECT_EQ(bgContinuousTaskMgr_->StopBackgroundRunningForInner(taskParam), ERR_OK);
967 }
968
969 /**
970 * @tc.name: BgTaskManagerUnitTest_044
971 * @tc.desc: test CheckBgmodeTypeForInner.
972 * @tc.type: FUNC
973 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
974 */
975 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_044, TestSize.Level1)
976 {
977 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(0), ERR_BGTASK_INVALID_BGMODE);
978 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(1), ERR_OK);
979 EXPECT_EQ(bgContinuousTaskMgr_->CheckBgmodeTypeForInner(10), ERR_OK);
980 }
981
982 /**
983 * @tc.name: BgTaskManagerUnitTest_045
984 * @tc.desc: test CheckProcessUidInfo.
985 * @tc.type: FUNC
986 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
987 */
988 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_045, TestSize.Level1)
989 {
990 std::vector<AppExecFwk::RunningProcessInfo> allProcesses;
991
992 AppExecFwk::RunningProcessInfo info1;
993 info1.uid_ = TEST_NUM_ONE;
994 allProcesses.push_back(info1);
995 EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), false);
996 AppExecFwk::RunningProcessInfo info2;
997 info2.uid_ = TEST_NUM_TWO;
998 allProcesses.push_back(info2);
999 EXPECT_EQ(bgContinuousTaskMgr_->CheckProcessUidInfo(allProcesses, TEST_NUM_TWO), true);
1000 }
1001
1002 /**
1003 * @tc.name: BgTaskManagerUnitTest_046
1004 * @tc.desc: test SendContinuousTaskNotification.
1005 * @tc.type: FUNC
1006 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
1007 */
1008 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_046, TestSize.Level1)
1009 {
1010 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1011 continuousTaskRecord->bgModeId_ = 2;
1012 continuousTaskRecord->isNewApi_ = true;
1013 continuousTaskRecord->uid_ = 1;
1014
1015 CachedBundleInfo info = CachedBundleInfo();
1016 info.abilityBgMode_["abilityName"] = 2;
1017 info.appName_ = "appName";
1018 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
1019
1020 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
1021 }
1022
1023 /**
1024 * @tc.name: BgTaskManagerUnitTest_047
1025 * @tc.desc: test GetNotificationText.
1026 * @tc.type: FUNC
1027 * @tc.require: issueIBOIHY
1028 */
1029 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_047, TestSize.Level1)
1030 {
1031 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1032 continuousTaskRecord->bgModeIds_.push_back(2);
1033 EXPECT_NE(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1034
1035 continuousTaskRecord->bgModeIds_.push_back(1);
1036 EXPECT_NE(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1037
1038 continuousTaskRecord->bgSubModeIds_.push_back(1);
1039 EXPECT_NE(bgContinuousTaskMgr_->GetNotificationText(continuousTaskRecord), "");
1040 }
1041
1042 /**
1043 * @tc.name: BgTaskManagerUnitTest_048
1044 * @tc.desc: test CheckSubMode.
1045 * @tc.type: FUNC
1046 * @tc.require: issueIBOIHY
1047 */
1048 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_048, TestSize.Level1)
1049 {
1050 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1051 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1052 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_OK);
1053
1054 want->SetParam(BG_TASK_SUB_MODE_TYPE, 0);
1055 continuousTaskRecord->bgModeIds_.push_back(1);
1056 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_BGTASK_CHECK_TASK_PARAM);
1057
1058 want->SetParam(BG_TASK_SUB_MODE_TYPE, 1);
1059 continuousTaskRecord->bgModeIds_.push_back(1);
1060 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_BGTASK_CHECK_TASK_PARAM);
1061
1062 continuousTaskRecord->bgModeIds_.push_back(5);
1063 EXPECT_EQ(bgContinuousTaskMgr_->CheckSubMode(want, continuousTaskRecord), ERR_OK);
1064 }
1065
1066 /**
1067 * @tc.name: BgTaskManagerUnitTest_049
1068 * @tc.desc: test CheckNotificationText.
1069 * @tc.type: FUNC
1070 * @tc.require: issueIBOIHY
1071 */
1072 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_049, TestSize.Level1)
1073 {
1074 std::string notificationText {""};
1075 std::shared_ptr<ContinuousTaskRecord> record = std::make_shared<ContinuousTaskRecord>();
1076 record->bgModeIds_.clear();
1077 record->bgModeIds_.push_back(2);
1078 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record), ERR_OK);
1079
1080 record->bgModeIds_.clear();
1081 record->bgModeIds_.push_back(100);
1082 bgContinuousTaskMgr_->continuousTaskText_.clear();
1083 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record),
1084 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
1085
1086 record->bgModeIds_.clear();
1087 record->bgModeIds_.push_back(5);
1088 record->bgSubModeIds_.push_back(1);
1089 bgContinuousTaskMgr_->continuousTaskSubText_.clear();
1090 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskText_), PROMPT_NUMS, "bgmmode_test");
1091 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record),
1092 ERR_BGTASK_NOTIFICATION_VERIFY_FAILED);
1093
1094 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskSubText_), PROMPT_NUMS, "bgmsubmode_test");
1095 EXPECT_EQ(bgContinuousTaskMgr_->CheckNotificationText(notificationText, record), ERR_OK);
1096 }
1097
1098 /**
1099 * @tc.name: BgTaskManagerUnitTest_050
1100 * @tc.desc: test SuspendContinuousTask.
1101 * @tc.type: FUNC
1102 * @tc.require: issueIC6B53
1103 */
1104 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_050, TestSize.Level1)
1105 {
1106 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1107 bgContinuousTaskMgr_->isSysReady_.store(false);
1108 bgContinuousTaskMgr_->SuspendContinuousTask(1, 1, 4, "");
1109 bgContinuousTaskMgr_->isSysReady_.store(true);
1110 bgContinuousTaskMgr_->SuspendContinuousTask(-1, 1, 4, "");
1111 SleepForFC();
1112 bgContinuousTaskMgr_->SuspendContinuousTask(1, 1, 4, "");
1113 EXPECT_TRUE(bgContinuousTaskMgr_->continuousTaskInfosMap_.empty());
1114 }
1115
1116 /**
1117 * @tc.name: BgTaskManagerUnitTest_051
1118 * @tc.desc: test HandleSuspendContinuousTask.
1119 * @tc.type: FUNC
1120 * @tc.require: issueIC6B53
1121 */
1122 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_051, TestSize.Level1)
1123 {
1124 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1125 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1126 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
1127 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
1128 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
1129 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
1130 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1131
1132 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1133 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
1134 // 查不到对应的key值
1135 bgContinuousTaskMgr_->HandleSuspendContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, 4, "");
1136 EXPECT_NE((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 0);
1137 // 查到对应的key值
1138 bgContinuousTaskMgr_->HandleSuspendContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, 4, "key1");
1139 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
1140 }
1141
1142 /**
1143 * @tc.name: BgTaskManagerUnitTest_052
1144 * @tc.desc: test ActiveContinuousTask.
1145 * @tc.type: FUNC
1146 * @tc.require: issueIC6B53
1147 */
1148 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_052, TestSize.Level1)
1149 {
1150 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1151 bgContinuousTaskMgr_->isSysReady_.store(false);
1152 bgContinuousTaskMgr_->ActiveContinuousTask(1, 1, "");
1153 bgContinuousTaskMgr_->isSysReady_.store(true);
1154 bgContinuousTaskMgr_->ActiveContinuousTask(1, 1, "");
1155 SleepForFC();
1156 bgContinuousTaskMgr_->ActiveContinuousTask(1, 1, "");
1157 EXPECT_TRUE(bgContinuousTaskMgr_->continuousTaskInfosMap_.empty());
1158 }
1159
1160 /**
1161 * @tc.name: BgTaskManagerUnitTest_053
1162 * @tc.desc: test HandleActiveContinuousTask.
1163 * @tc.type: FUNC
1164 * @tc.require: issueIC6B53
1165 */
1166 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_053, TestSize.Level1)
1167 {
1168 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1169 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1170 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
1171 continuousTaskRecord1->bgModeId_ = TEST_NUM_ONE;
1172 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord2 = std::make_shared<ContinuousTaskRecord>();
1173 continuousTaskRecord1->uid_ = TEST_NUM_ONE;
1174 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1175
1176 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1177 bgContinuousTaskMgr_->continuousTaskInfosMap_["key2"] = continuousTaskRecord2;
1178 // 暂停长时任务
1179 bgContinuousTaskMgr_->HandleSuspendContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, 4, "key1");
1180 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
1181 // 恢复长时任务
1182 bgContinuousTaskMgr_->HandleActiveContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, "");
1183 bgContinuousTaskMgr_->HandleActiveContinuousTask(TEST_NUM_ONE, TEST_NUM_ONE, "key1");
1184 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->continuousTaskInfosMap_.size(), 2);
1185 }
1186
1187 /**
1188 * @tc.name: GetAllContinuousTasks_001
1189 * @tc.desc: test GetAllContinuousTasks interface.
1190 * @tc.type: FUNC
1191 * @tc.require: issueIBY0DN
1192 */
1193 HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasks_001, TestSize.Level1)
1194 {
1195 bgContinuousTaskMgr_->isSysReady_.store(false);
1196 std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
1197 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list), ERR_BGTASK_SYS_NOT_READY);
1198
1199 bgContinuousTaskMgr_->isSysReady_.store(true);
1200 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list), ERR_OK);
1201
1202 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1203 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1204 continuousTaskRecord1->abilityName_ = "abilityName";
1205 continuousTaskRecord1->uid_ = 1;
1206 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1207 continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
1208 continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
1209 continuousTaskRecord1->notificationId_ = 1;
1210 continuousTaskRecord1->continuousTaskId_ = 1;
1211 continuousTaskRecord1->abilityId_ = 1;
1212 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
1213 info->bundleName_ = "wantAgentBundleName";
1214 info->abilityName_ = "wantAgentAbilityName";
1215 continuousTaskRecord1->wantAgentInfo_ = info;
1216 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1217
1218 std::vector<std::shared_ptr<ContinuousTaskInfo>> list2;
1219 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list2), ERR_OK);
1220 }
1221
1222 /**
1223 * @tc.name: GetAllContinuousTasks_002
1224 * @tc.desc: test GetAllContinuousTasks interface.
1225 * @tc.type: FUNC
1226 * @tc.require: issuesICRZHF
1227 */
1228 HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasks_002, TestSize.Level1)
1229 {
1230 bgContinuousTaskMgr_->isSysReady_.store(false);
1231 std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
1232 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list, true), ERR_BGTASK_SYS_NOT_READY);
1233
1234 bgContinuousTaskMgr_->isSysReady_.store(true);
1235 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list, true), ERR_OK);
1236
1237 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1238 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1239 continuousTaskRecord1->abilityName_ = "abilityName";
1240 continuousTaskRecord1->uid_ = 1;
1241 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1242 continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
1243 continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
1244 continuousTaskRecord1->notificationId_ = 1;
1245 continuousTaskRecord1->continuousTaskId_ = 1;
1246 continuousTaskRecord1->abilityId_ = 1;
1247 continuousTaskRecord1->suspendState_ = true;
1248
1249 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
1250 info->bundleName_ = "wantAgentBundleName";
1251 info->abilityName_ = "wantAgentAbilityName";
1252 continuousTaskRecord1->wantAgentInfo_ = info;
1253 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1254
1255 std::vector<std::shared_ptr<ContinuousTaskInfo>> list2;
1256 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list2, false), ERR_OK);
1257 EXPECT_TRUE(list2.empty());
1258 }
1259
1260 /**
1261 * @tc.name: GetAllContinuousTasksInner_001
1262 * @tc.desc: test GetAllContinuousTasksInner interface.
1263 * @tc.type: FUNC
1264 * @tc.require: issuesICRZHF
1265 */
1266 HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasksInner_001, TestSize.Level1)
1267 {
1268 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1269 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1270 continuousTaskRecord1->abilityName_ = "abilityName";
1271 continuousTaskRecord1->uid_ = 1;
1272 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1273 continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
1274 continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
1275 continuousTaskRecord1->notificationId_ = 1;
1276 continuousTaskRecord1->continuousTaskId_ = 1;
1277 continuousTaskRecord1->abilityId_ = 1;
1278 continuousTaskRecord1->suspendState_ = true;
1279
1280 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
1281 info->bundleName_ = "wantAgentBundleName";
1282 info->abilityName_ = "wantAgentAbilityName";
1283 continuousTaskRecord1->wantAgentInfo_ = info;
1284 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1285
1286 std::vector<std::shared_ptr<ContinuousTaskInfo>> list3;
1287 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasksInner(100, list3, true), ERR_OK);
1288 EXPECT_TRUE(list3.empty());
1289 EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasksInner(1, list3, true), ERR_OK);
1290 EXPECT_FALSE(list3.empty());
1291 }
1292
1293 /**
1294 * @tc.name: RequestGetContinuousTasksByUidForInner_001
1295 * @tc.desc: test RequestGetContinuousTasksByUidForInner interface.
1296 * @tc.type: FUNC
1297 * @tc.require: issueIBY0DN
1298 */
1299 HWTEST_F(BgContinuousTaskMgrTest, RequestGetContinuousTasksByUidForInner_001, TestSize.Level1)
1300 {
1301 bgContinuousTaskMgr_->isSysReady_.store(false);
1302 std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
1303 int32_t uid = 1;
1304 EXPECT_EQ(bgContinuousTaskMgr_->RequestGetContinuousTasksByUidForInner(uid, list), ERR_BGTASK_SYS_NOT_READY);
1305
1306 bgContinuousTaskMgr_->isSysReady_.store(true);
1307 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1308 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1309 continuousTaskRecord1->abilityName_ = "abilityName";
1310 continuousTaskRecord1->uid_ = 1;
1311 continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
1312 continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
1313 continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
1314 continuousTaskRecord1->notificationId_ = 1;
1315 continuousTaskRecord1->continuousTaskId_ = 1;
1316 continuousTaskRecord1->abilityId_ = 1;
1317 std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
1318 info->bundleName_ = "wantAgentBundleName";
1319 info->abilityName_ = "wantAgentAbilityName";
1320 continuousTaskRecord1->wantAgentInfo_ = info;
1321 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1322 uid = 2;
1323 EXPECT_EQ(bgContinuousTaskMgr_->RequestGetContinuousTasksByUidForInner(uid, list), ERR_OK);
1324
1325 uid = 1;
1326 std::vector<std::shared_ptr<ContinuousTaskInfo>> list2;
1327 EXPECT_EQ(bgContinuousTaskMgr_->RequestGetContinuousTasksByUidForInner(uid, list2), ERR_OK);
1328 }
1329
1330 /**
1331 * @tc.name: AVSessionNotifyUpdateNotification_001
1332 * @tc.desc: test AVSessionNotifyUpdateNotification interface.
1333 * @tc.type: FUNC
1334 * @tc.require: issueIC9VN9
1335 */
1336 HWTEST_F(BgContinuousTaskMgrTest, AVSessionNotifyUpdateNotification_001, TestSize.Level1)
1337 {
1338 bgContinuousTaskMgr_->isSysReady_.store(false);
1339 int32_t uid = 0;
1340 int32_t pid = 1;
1341 EXPECT_EQ(bgContinuousTaskMgr_->AVSessionNotifyUpdateNotification(uid, pid, true), ERR_BGTASK_SYS_NOT_READY);
1342
1343 bgContinuousTaskMgr_->isSysReady_.store(true);
1344 EXPECT_EQ(bgContinuousTaskMgr_->AVSessionNotifyUpdateNotification(uid, pid, true), ERR_BGTASK_CHECK_TASK_PARAM);
1345 }
1346
1347 /**
1348 * @tc.name: AVSessionNotifyUpdateNotification_002
1349 * @tc.desc: test AVSessionNotifyUpdateNotification interface.
1350 * @tc.type: FUNC
1351 * @tc.require: issueIC9VN9
1352 */
1353 HWTEST_F(BgContinuousTaskMgrTest, AVSessionNotifyUpdateNotification_002, TestSize.Level1)
1354 {
1355 int32_t uid = 0;
1356 int32_t pid = 1;
1357 bgContinuousTaskMgr_->isSysReady_.store(true);
1358 EXPECT_EQ(bgContinuousTaskMgr_->AVSessionNotifyUpdateNotificationInner(uid, pid, true),
1359 ERR_BGTASK_OBJECT_NOT_EXIST);
1360
1361 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1362 uid = 1;
1363 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
1364 continuousTaskRecord1->uid_ = 1;
1365 continuousTaskRecord1->bgModeId_ = 2;
1366 continuousTaskRecord1->isNewApi_ = true;
1367 continuousTaskRecord1->notificationId_ = 1;
1368 continuousTaskRecord1->continuousTaskId_ = 1;
1369 continuousTaskRecord1->notificationLabel_ = "label1";
1370
1371 CachedBundleInfo info = CachedBundleInfo();
1372 info.abilityBgMode_["abilityName"] = 2;
1373 info.appName_ = "appName";
1374 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
1375 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
1376 EXPECT_EQ(bgContinuousTaskMgr_->AVSessionNotifyUpdateNotificationInner(uid, pid, true), ERR_OK);
1377 EXPECT_EQ(bgContinuousTaskMgr_->AVSessionNotifyUpdateNotificationInner(uid, pid, false), ERR_OK);
1378 }
1379
1380 /**
1381 * @tc.name: BgTaskManagerUnitTest_054
1382 * @tc.desc: test SendContinuousTaskNotification.
1383 * @tc.type: FUNC
1384 * @tc.require: issueICC87K
1385 */
1386 HWTEST_F(BgContinuousTaskMgrTest, BgTaskManagerUnitTest_054, TestSize.Level1)
1387 {
1388 std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord = std::make_shared<ContinuousTaskRecord>();
1389 bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
1390 CachedBundleInfo info = CachedBundleInfo();
1391 info.abilityBgMode_["abilityName"] = 1;
1392 info.appName_ = "appName";
1393 bgContinuousTaskMgr_->cachedBundleInfos_.emplace(1, info);
1394 continuousTaskRecord->uid_ = 1;
1395 continuousTaskRecord->bgModeId_ = 2;
1396 continuousTaskRecord->bgModeIds_.clear();
1397 continuousTaskRecord->bgModeIds_.push_back(continuousTaskRecord->bgModeId_);
1398 bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord;
1399 EXPECT_EQ(bgContinuousTaskMgr_->SendContinuousTaskNotification(continuousTaskRecord), ERR_OK);
1400 }
1401 } // namespace BackgroundTaskMgr
1402 } // namespace OHOS