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