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