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 #include <gtest/gtest.h>
20
21 #include "bgtask_common.h"
22 #include "background_task_subscriber.h"
23 #include "background_task_subscriber_proxy.h"
24 #include "bg_transient_task_mgr.h"
25 #include "bgtaskmgr_inner_errors.h"
26 #include "bundle_mgr_interface.h"
27 #include "config_data_source_type.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
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace BackgroundTaskMgr {
39 namespace {
40 static constexpr int32_t SLEEP_TIME = 500;
41 static constexpr int32_t DEFAULT_USERID = 100;
42 static constexpr int32_t JSON_FORMAT_DUMP = 4;
43 static constexpr int32_t TRANSIENT_EXEMPTED_QUOTA_TIME = 10000;
44 static constexpr char TRANSIENT_ERR_DELAYED_FROZEN_LIST[] = "transient_err_delayed_frozen_list";
45 static constexpr char CONTINUOUS_TASK_KEEPING_EXEMPTED_LIST[] = "continuous_task_keeping_exemption_list";
46 static constexpr char TRANSIENT_ERR_DELAYED_FROZEN_TIME[] = "transient_err_delayed_frozen_time";
47 static constexpr char TRANSIENT_EXEMPTED_QUOTA[] = "transient_exempted_quota";
48 static constexpr char CONFIG_JSON_INDEX_TOP[] = "params";
49 static constexpr char CONFIG_JSON_INDEX_SUSPEND_SECOND[] = "param";
50 static constexpr char LAUNCHER_BUNDLE_NAME[] = "com.ohos.launcher";
51 static constexpr char SCB_BUNDLE_NAME[] = "com.ohos.sceneboard";
52 }
53 class BgTaskManagerUnitTest : public testing::Test {
54 public:
55 static void SetUpTestCase();
56 static void TearDownTestCase();
57 void SetUp();
58 void TearDown();
SleepForFC()59 inline void SleepForFC()
60 {
61 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
62 }
63
64 static std::shared_ptr<BgTransientTaskMgr> bgTransientTaskMgr_;
65
GetUidByBundleName(const std::string & bundleName,const int32_t userId)66 int32_t GetUidByBundleName(const std::string &bundleName, const int32_t userId)
67 {
68 sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
69 if (systemMgr == nullptr) {
70 return -1;
71 }
72
73 sptr<IRemoteObject> remoteObject = systemMgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
74 if (remoteObject == nullptr) {
75 return -1;
76 }
77
78 sptr<OHOS::AppExecFwk::IBundleMgr> bundleMgrProxy = iface_cast<OHOS::AppExecFwk::IBundleMgr>(remoteObject);
79 if (bundleMgrProxy == nullptr) {
80 return -1;
81 }
82
83 return bundleMgrProxy->GetUidByBundleName(bundleName, userId);
84 }
85 };
86
87 std::shared_ptr<BgTransientTaskMgr> BgTaskManagerUnitTest::bgTransientTaskMgr_ = nullptr;
88
SetUpTestCase()89 void BgTaskManagerUnitTest::SetUpTestCase()
90 {
91 bgTransientTaskMgr_ = DelayedSingleton<BgTransientTaskMgr>::GetInstance();
92 }
93
TearDownTestCase()94 void BgTaskManagerUnitTest::TearDownTestCase() {}
95
SetUp()96 void BgTaskManagerUnitTest::SetUp() {}
97
TearDown()98 void BgTaskManagerUnitTest::TearDown() {}
99
100 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {};
101
102 class TestExpiredCallbackStub : public ExpiredCallbackStub {
103 public:
OnExpired()104 ErrCode OnExpired() override {return ERR_OK;}
105 };
106
107 /**
108 * @tc.name: BgTaskManagerUnitTest_018
109 * @tc.desc: test BgTransientTaskMgr init.
110 * @tc.type: FUNC
111 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
112 */
113 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_018, TestSize.Level0)
114 {
115 EXPECT_EQ(bgTransientTaskMgr_->isReady_.load(), false);
116 bgTransientTaskMgr_->Init(AppExecFwk::EventRunner::Create("tdd_test_handler"));
117 EXPECT_EQ(bgTransientTaskMgr_->isReady_.load(), true);
118 }
119
120 /**
121 * @tc.name: BgTaskManagerUnitTest_019
122 * @tc.desc: test IsCallingInfoLegal.
123 * @tc.type: FUNC
124 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
125 */
126 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_019, TestSize.Level0)
127 {
128 std::string bundleName;
129 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(-1, -1, bundleName, nullptr), ERR_BGTASK_INVALID_PID_OR_UID);
130 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(1, 1, bundleName, nullptr), ERR_BGTASK_INVALID_BUNDLE_NAME);
131 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, DEFAULT_USERID);
132 if (uid == -1) {
133 uid = GetUidByBundleName(SCB_BUNDLE_NAME, DEFAULT_USERID);
134 }
135 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, nullptr), ERR_BGTASK_INVALID_CALLBACK);
136 sptr<ExpiredCallbackProxy> proxy1 = sptr<ExpiredCallbackProxy>(new ExpiredCallbackProxy(nullptr));
137 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, proxy1), ERR_BGTASK_INVALID_CALLBACK);
138 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
139 sptr<ExpiredCallbackProxy> proxy2 = sptr<ExpiredCallbackProxy>(
140 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
141 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, proxy2), ERR_OK);
142 }
143
144 /**
145 * @tc.name: BgTaskManagerUnitTest_020
146 * @tc.desc: test RequestSuspendDelay.
147 * @tc.type: FUNC
148 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
149 */
150 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_020, TestSize.Level0)
151 {
152 std::shared_ptr<DelaySuspendInfo> delayInfo = std::make_shared<DelaySuspendInfo>();
153 bgTransientTaskMgr_->isReady_.store(false);
154 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", nullptr, delayInfo), ERR_BGTASK_SYS_NOT_READY);
155 bgTransientTaskMgr_->isReady_.store(true);
156 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", nullptr, delayInfo), ERR_BGTASK_INVALID_CALLBACK);
157
158 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
159 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
160 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
161
162 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
163 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", proxy, delayInfo), ERR_BGTASK_CALLBACK_EXISTS);
164 bgTransientTaskMgr_->expiredCallbackMap_.clear();
165 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", proxy, delayInfo), ERR_OK);
166 }
167
168 /**
169 * @tc.name: BgTaskManagerUnitTest_021
170 * @tc.desc: test HandleTransientTaskSuscriberTask.
171 * @tc.type: FUNC
172 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
173 */
174 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_021, TestSize.Level0)
175 {
176 bgTransientTaskMgr_->handler_ = nullptr;
177 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(nullptr, TransientTaskEventType::TASK_START);
178 bgTransientTaskMgr_->handler_ =
179 std::make_shared<AppExecFwk::EventHandler>(AppExecFwk::EventRunner::Create("tdd_test_handler"));
180 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(nullptr, TransientTaskEventType::TASK_START);
181
182 shared_ptr<TransientTaskAppInfo> appInfo = std::make_shared<TransientTaskAppInfo>();
183 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_START);
184
185 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
186 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber.GetImpl());
187 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_START);
188 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_END);
189 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::APP_TASK_START);
190 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::APP_TASK_END);
191 bgTransientTaskMgr_->subscriberList_.clear();
192 EXPECT_TRUE(true);
193 }
194
195 /**
196 * @tc.name: BgTaskManagerUnitTest_022
197 * @tc.desc: test CancelSuspendDelay.
198 * @tc.type: FUNC
199 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
200 */
201 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_022, TestSize.Level0)
202 {
203 bgTransientTaskMgr_->keyInfoMap_.clear();
204 bgTransientTaskMgr_->isReady_.store(false);
205 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelay(-1), ERR_BGTASK_SYS_NOT_READY);
206 bgTransientTaskMgr_->isReady_.store(true);
207 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelay(1), ERR_BGTASK_INVALID_REQUEST_ID);
208 std::string bundleName = LAUNCHER_BUNDLE_NAME;
209 int32_t uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
210 if (uid == -1) {
211 bundleName = SCB_BUNDLE_NAME;
212 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
213 }
214 auto keyInfo = std::make_shared<KeyInfo>(bundleName, uid);
215 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
216 bgTransientTaskMgr_->CancelSuspendDelay(1);
217 EXPECT_TRUE(true);
218 }
219
220 /**
221 * @tc.name: BgTaskManagerUnitTest_023
222 * @tc.desc: test CancelSuspendDelayLocked.
223 * @tc.type: FUNC
224 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
225 */
226 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_023, TestSize.Level0)
227 {
228 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelayLocked(-1), ERR_BGTASK_CALLBACK_NOT_EXIST);
229
230 sptr<ExpiredCallbackProxy> proxy1 = sptr<ExpiredCallbackProxy>(new ExpiredCallbackProxy(nullptr));
231 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy1;
232 bgTransientTaskMgr_->CancelSuspendDelayLocked(-1);
233
234 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
235 sptr<ExpiredCallbackProxy> proxy2 = sptr<ExpiredCallbackProxy>(
236 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
237 bgTransientTaskMgr_->CancelSuspendDelayLocked(-1);
238 EXPECT_TRUE(true);
239 }
240
241 /**
242 * @tc.name: BgTaskManagerUnitTest_024
243 * @tc.desc: test ForceCancelSuspendDelay.
244 * @tc.type: FUNC
245 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
246 */
247 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_024, TestSize.Level0)
248 {
249 bgTransientTaskMgr_->keyInfoMap_.clear();
250 bgTransientTaskMgr_->ForceCancelSuspendDelay(1);
251
252 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
253 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
254 bgTransientTaskMgr_->ForceCancelSuspendDelay(1);
255 EXPECT_TRUE(true);
256 }
257
258 /**
259 * @tc.name: BgTaskManagerUnitTest_025
260 * @tc.desc: test GetRemainingDelayTime.
261 * @tc.type: FUNC
262 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
263 */
264 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_025, TestSize.Level0)
265 {
266 int32_t delayTime;
267 bgTransientTaskMgr_->isReady_.store(false);
268 EXPECT_EQ(bgTransientTaskMgr_->GetRemainingDelayTime(-1, delayTime), ERR_BGTASK_SYS_NOT_READY);
269 bgTransientTaskMgr_->isReady_.store(true);
270 EXPECT_EQ(bgTransientTaskMgr_->GetRemainingDelayTime(1, delayTime), ERR_BGTASK_INVALID_REQUEST_ID);
271 std::string bundleName = LAUNCHER_BUNDLE_NAME;
272 int32_t uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
273 if (uid == -1) {
274 bundleName = SCB_BUNDLE_NAME;
275 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
276 }
277 auto keyInfo = std::make_shared<KeyInfo>(bundleName, uid);
278 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
279 bgTransientTaskMgr_->GetRemainingDelayTime(1, delayTime);
280 EXPECT_TRUE(true);
281 }
282
283 /**
284 * @tc.name: BgTaskManagerUnitTest_026
285 * @tc.desc: test HandleExpiredCallbackDeath.
286 * @tc.type: FUNC
287 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
288 */
289 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_026, TestSize.Level0)
290 {
291 bgTransientTaskMgr_->HandleExpiredCallbackDeath(nullptr);
292 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
293 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
294 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
295 bgTransientTaskMgr_->expiredCallbackMap_.clear();
296 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
297
298 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
299 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
300
301 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
302 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
303 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
304 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
305 bgTransientTaskMgr_->keyInfoMap_.clear();
306 bgTransientTaskMgr_->expiredCallbackMap_.clear();
307 EXPECT_TRUE(true);
308 }
309
310 /**
311 * @tc.name: BgTaskManagerUnitTest_027
312 * @tc.desc: test HandleSubscriberDeath.
313 * @tc.type: FUNC
314 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
315 */
316 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_027, TestSize.Level1)
317 {
318 bgTransientTaskMgr_->subscriberList_.clear();
319 bgTransientTaskMgr_->HandleSubscriberDeath(nullptr);
320 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
321 bgTransientTaskMgr_->HandleSubscriberDeath(subscriber.GetImpl());
322 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber.GetImpl());
323 bgTransientTaskMgr_->HandleSubscriberDeath(subscriber.GetImpl());
324 EXPECT_TRUE(true);
325 }
326
327 /**
328 * @tc.name: BgTaskManagerUnitTest_028
329 * @tc.desc: test HandleRequestExpired.
330 * @tc.type: FUNC
331 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
332 */
333 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_028, TestSize.Level1)
334 {
335 bgTransientTaskMgr_->keyInfoMap_.clear();
336 bgTransientTaskMgr_->expiredCallbackMap_.clear();
337 bgTransientTaskMgr_->HandleRequestExpired(1);
338 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
339 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
340 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
341 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
342 bgTransientTaskMgr_->HandleRequestExpired(1);
343 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
344 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
345 bgTransientTaskMgr_->HandleRequestExpired(1);
346 EXPECT_TRUE(true);
347 }
348
349 /**
350 * @tc.name: BgTaskManagerUnitTest_029
351 * @tc.desc: test SubscribeBackgroundTask.
352 * @tc.type: FUNC
353 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
354 */
355 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_029, TestSize.Level1)
356 {
357 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(nullptr), ERR_BGTASK_INVALID_PARAM);
358 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
359 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
360 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
361 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
362 sptr<BackgroundTaskSubscriberProxy> subscirberProxy2
363 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(subscriber.GetImpl()));
364 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy2), ERR_OK);
365
366 bgTransientTaskMgr_->subscriberList_.emplace_back(subscirberProxy2);
367 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy2), ERR_OK);
368 }
369
370 /**
371 * @tc.name: BgTaskManagerUnitTest_030
372 * @tc.desc: test UnsubscribeBackgroundTask.
373 * @tc.type: FUNC
374 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
375 */
376 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_030, TestSize.Level1)
377 {
378 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(nullptr), ERR_BGTASK_INVALID_PARAM);
379 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
380 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
381 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
382 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
383 sptr<BackgroundTaskSubscriberProxy> subscirberProxy2
384 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(subscriber.GetImpl()));
385 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy2), ERR_OK);
386
387 bgTransientTaskMgr_->subscriberList_.emplace_back(subscirberProxy2);
388 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy2), ERR_OK);
389 }
390
391 /**
392 * @tc.name: BgTaskManagerUnitTest_031
393 * @tc.desc: test GetTransientTaskApps.
394 * @tc.type: FUNC
395 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
396 */
397 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_031, TestSize.Level1)
398 {
399 std::vector<std::shared_ptr<TransientTaskAppInfo>> list;
400 bgTransientTaskMgr_->keyInfoMap_.clear();
401 EXPECT_EQ(bgTransientTaskMgr_->GetTransientTaskApps(list), ERR_OK);
402
403 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
404 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
405 EXPECT_EQ(bgTransientTaskMgr_->GetTransientTaskApps(list), ERR_OK);
406 }
407
408 /**
409 * @tc.name: BgTaskManagerUnitTest_032
410 * @tc.desc: test ShellDump.
411 * @tc.type: FUNC
412 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
413 */
414 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_032, TestSize.Level1)
415 {
416 bgTransientTaskMgr_->keyInfoMap_.clear();
417 std::vector<std::string> dumpOption;
418 std::vector<std::string> dumpInfo;
419 bgTransientTaskMgr_->isReady_.store(false);
420 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_SYS_NOT_READY);
421 bgTransientTaskMgr_->isReady_.store(true);
422 dumpOption.emplace_back("-C");
423 dumpOption.emplace_back("All");
424 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
425 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
426 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
427 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
428 dumpOption.pop_back();
429 dumpOption.emplace_back("BATTARY_LOW");
430 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
431 dumpOption.pop_back();
432 dumpOption.emplace_back("BATTARY_OKAY");
433 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
434 dumpOption.pop_back();
435 dumpOption.emplace_back("DUMP_CANCEL");
436 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
437 dumpOption.pop_back();
438 dumpOption.emplace_back("PAUSE");
439 dumpOption.emplace_back("1");
440 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
441 dumpOption.pop_back();
442 dumpOption.pop_back();
443 dumpOption.emplace_back("START");
444 dumpOption.emplace_back("1");
445 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
446 dumpOption.pop_back();
447 dumpOption.pop_back();
448 dumpOption.emplace_back("invalid");
449 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_PERMISSION_DENIED);
450 }
451
452 /**
453 * @tc.name: BgTaskManagerUnitTest_040
454 * @tc.desc: test ResourcesSubscriberMgr AddSubscriber.
455 * @tc.type: FUNC
456 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
457 */
458 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_040, TestSize.Level1)
459 {
460 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.clear();
461 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
462 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
463 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->AddSubscriber(subscirberProxy1),
464 ERR_BGTASK_INVALID_PARAM);
465 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscirberProxy1),
466 ERR_BGTASK_INVALID_PARAM);
467 }
468
469 /**
470 * @tc.name: BgTaskManagerUnitTest_041
471 * @tc.desc: test ResourcesSubscriberMgr OnResourceChanged.
472 * @tc.type: FUNC
473 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
474 */
475 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_041, TestSize.Level1)
476 {
477 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(nullptr,
478 EfficiencyResourcesEventType::APP_RESOURCE_APPLY);
479 auto callbackInfo = std::make_shared<ResourceCallbackInfo>();
480 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
481 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.emplace_back(subscriber1.GetImpl());
482
483 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
484 EfficiencyResourcesEventType::APP_RESOURCE_APPLY);
485 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
486 EfficiencyResourcesEventType::RESOURCE_APPLY);
487 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
488 EfficiencyResourcesEventType::APP_RESOURCE_RESET);
489 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
490 EfficiencyResourcesEventType::RESOURCE_RESET);
491 EXPECT_EQ((int32_t)DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.size(), 1);
492 }
493
494 /**
495 * @tc.name: BgTaskManagerUnitTest_042
496 * @tc.desc: test BgTransientTaskMgr NotifyTransientTaskSuscriber.
497 * @tc.type: FUNC
498 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
499 */
500 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_042, TestSize.Level1)
501 {
502 bgTransientTaskMgr_->subscriberList_.clear();
503 auto taskInfo = std::make_shared<TransientTaskAppInfo>();
504 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
505 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber1.GetImpl());
506
507 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo, TransientTaskEventType::TASK_START);
508 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo, TransientTaskEventType::TASK_END);
509 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo, TransientTaskEventType::TASK_ERR);
510 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo, TransientTaskEventType::APP_TASK_START);
511 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo, TransientTaskEventType::APP_TASK_END);
512 EXPECT_NE((int32_t)bgTransientTaskMgr_->subscriberList_.size(), 0);
513 }
514
515 /**
516 * @tc.name: BgTaskManagerUnitTest_043
517 * @tc.desc: test BgTransientTaskMgr PauseTransientTaskTimeForInner.
518 * @tc.type: FUNC
519 * @tc.require: issueI936BL
520 */
521 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_043, TestSize.Level1)
522 {
523 int32_t uid = -1;
524 bgTransientTaskMgr_->isReady_.store(false);
525 EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_SYS_NOT_READY);
526
527 bgTransientTaskMgr_->isReady_.store(true);
528 EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_INVALID_PID_OR_UID);
529
530 uid = 1;
531 EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_SERVICE_INNER_ERROR);
532
533 std::string bundleName = LAUNCHER_BUNDLE_NAME;
534 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
535 if (uid == -1) {
536 bundleName = SCB_BUNDLE_NAME;
537 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
538 }
539 EXPECT_NE(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_OK);
540 }
541
542 /**
543 * @tc.name: BgTaskManagerUnitTest_044
544 * @tc.desc: test BgTransientTaskMgr StartTransientTaskTimeForInner.
545 * @tc.type: FUNC
546 * @tc.require: issueI936BL
547 */
548 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_044, TestSize.Level1)
549 {
550 int32_t uid = -1;
551 bgTransientTaskMgr_->isReady_.store(false);
552 EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_SYS_NOT_READY);
553
554 bgTransientTaskMgr_->isReady_.store(true);
555 EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_INVALID_PID_OR_UID);
556
557 uid = 1;
558 EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_SERVICE_INNER_ERROR);
559
560 std::string bundleName = LAUNCHER_BUNDLE_NAME;
561 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
562 if (uid == -1) {
563 bundleName = SCB_BUNDLE_NAME;
564 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
565 }
566 EXPECT_NE(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_OK);
567 }
568
569 /**
570 * @tc.name: BgTaskManagerUnitTest_045
571 * @tc.desc: test BgTransientTaskMgr SendCloudConfig.
572 * @tc.type: FUNC
573 * @tc.require: issueI936BL
574 */
575 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_045, TestSize.Level1)
576 {
577 bgTransientTaskMgr_->isReady_.store(false);
578 EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig("", ConfigDataSourceType::CONFIG_CLOUD), ERR_BGTASK_SYS_NOT_READY);
579
580 bgTransientTaskMgr_->isReady_.store(true);
581 EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig("", ConfigDataSourceType::CONFIG_CLOUD), ERR_PARAM_NUMBER_ERR);
582
583 auto appInfo = nlohmann::json::array();
584 appInfo.push_back("com.myapplication.demo1");
585 appInfo.push_back("com.myapplication.demo2");
586 nlohmann::json appParam;
587 appParam[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = appInfo;
588 appParam[TRANSIENT_ERR_DELAYED_FROZEN_TIME] = TRANSIENT_EXEMPTED_QUOTA_TIME;
589 const std::string strParam = appParam.dump(JSON_FORMAT_DUMP);
590 EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig(strParam, ConfigDataSourceType::CONFIG_SUSPEND_MANAGER), ERR_OK);
591
592 nlohmann::json param;
593 param[TRANSIENT_EXEMPTED_QUOTA] = TRANSIENT_EXEMPTED_QUOTA_TIME;
594 nlohmann::json params;
595 params[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = appInfo;
596
597 auto appInfo2 = nlohmann::json::array();
598 appInfo2.push_back("com.myapplication.demo1");
599 appInfo2.push_back("com.myapplication.demo2");
600 params[CONTINUOUS_TASK_KEEPING_EXEMPTED_LIST] = appInfo2;
601 params[CONFIG_JSON_INDEX_SUSPEND_SECOND] = param;
602 nlohmann::json cloudConfig;
603 cloudConfig[CONFIG_JSON_INDEX_TOP] = params;
604 const std::string cloudConfigStr = cloudConfig.dump(JSON_FORMAT_DUMP);
605 EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig(cloudConfigStr, ConfigDataSourceType::CONFIG_CLOUD), ERR_OK);
606 }
607
608 /**
609 * @tc.name: BgTaskManagerUnitTest_046
610 * @tc.desc: test BgTransientTaskMgr OnAppCacheStateChanged.
611 * @tc.type: FUNC
612 * @tc.require: issueIB08SV
613 */
614 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_046, TestSize.Level1)
615 {
616 int32_t uid = 1;
617 int32_t pid = 1;
618 std::string bundleName = "bundleName";
619 bgTransientTaskMgr_->isReady_.store(false);
620 bgTransientTaskMgr_->OnAppCacheStateChanged(uid, pid, bundleName);
621
622 bgTransientTaskMgr_->isReady_.store(true);
623 uid = -1;
624 bgTransientTaskMgr_->OnAppCacheStateChanged(uid, pid, bundleName);
625
626 uid = 1;
627 bgTransientTaskMgr_->OnAppCacheStateChanged(uid, pid, bundleName);
628 EXPECT_NE(bgTransientTaskMgr_->CancelSuspendDelay(-1), ERR_OK);
629 }
630
631 /**
632 * @tc.name: BgTaskManagerUnitTest_047
633 * @tc.desc: test BgTransientTaskMgr HandleSuspendManagerDie.
634 * @tc.type: FUNC
635 * @tc.require: issueIB08SV
636 */
637 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_047, TestSize.Level1)
638 {
639 bgTransientTaskMgr_->HandleSuspendManagerDie();
640
641 bgTransientTaskMgr_->transientPauseUid_.insert(1);
642 bgTransientTaskMgr_->HandleSuspendManagerDie();
643 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, DEFAULT_USERID);
644 if (uid == -1) {
645 uid = GetUidByBundleName(SCB_BUNDLE_NAME, DEFAULT_USERID);
646 }
647 bgTransientTaskMgr_->transientPauseUid_.insert(uid);
648 bgTransientTaskMgr_->HandleSuspendManagerDie();
649 EXPECT_EQ(bgTransientTaskMgr_->transientPauseUid_.size(), 0);
650 }
651
652 /**
653 * @tc.name: BgTaskManagerUnitTest_048
654 * @tc.desc: test BgTransientTaskMgr DumpTaskTime.
655 * @tc.type: FUNC
656 * @tc.require: issueIB08SV
657 */
658 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_048, TestSize.Level1)
659 {
660 std::vector<std::string> dumpOption;
661 std::vector<std::string> dumpInfo;
662 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, DEFAULT_USERID);
663 if (uid == -1) {
664 uid = GetUidByBundleName(SCB_BUNDLE_NAME, DEFAULT_USERID);
665 }
666 std::string sUid = std::to_string(uid);
667 dumpOption.emplace_back("-C");
668 dumpOption.emplace_back("START");
669 dumpOption.emplace_back(sUid);
670 bgTransientTaskMgr_->DumpTaskTime(dumpOption, true, dumpInfo);
671 EXPECT_EQ(dumpInfo.size(), 1);
672 bgTransientTaskMgr_->DumpTaskTime(dumpOption, false, dumpInfo);
673 EXPECT_EQ(dumpInfo.size(), 2);
674 }
675
676 /**
677 * @tc.name: BgTaskManagerUnitTest_049
678 * @tc.desc: test BgTransientTaskMgr OnRemoveSystemAbility.
679 * @tc.type: FUNC
680 * @tc.require: issueIB08SV
681 */
682 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_049, TestSize.Level1)
683 {
684 bgTransientTaskMgr_->isReady_.store(true);
685 bgTransientTaskMgr_->OnRemoveSystemAbility(-1, "");
686 bgTransientTaskMgr_->OnRemoveSystemAbility(SUSPEND_MANAGER_SYSTEM_ABILITY_ID, "");
687 EXPECT_TRUE(true);
688 }
689
690 /**
691 * @tc.name: BgTaskManagerUnitTest_050
692 * @tc.desc: test BgtaskConfig Init.
693 * @tc.type: FUNC
694 * @tc.require: DTS2025031836567
695 */
696 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_050, TestSize.Level1)
697 {
698 DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.clear();
699 DelayedSingleton<BgtaskConfig>::GetInstance()->isInit_ = true;
700 DelayedSingleton<BgtaskConfig>::GetInstance()->Init();
701
702 EXPECT_EQ(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
703 }
704
705 /**
706 * @tc.name: BgTaskManagerUnitTest_051
707 * @tc.desc: test BgtaskConfig Init.
708 * @tc.type: FUNC
709 * @tc.require: DTS2025031836567
710 */
711 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_051, TestSize.Level1)
712 {
713 DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.clear();
714 DelayedSingleton<BgtaskConfig>::GetInstance()->isInit_ = false;
715 DelayedSingleton<BgtaskConfig>::GetInstance()->Init();
716 DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.emplace("com.myapplication.demo");
717 EXPECT_NE(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
718 }
719
720 /**
721 * @tc.name: BgTaskManagerUnitTest_052
722 * @tc.desc: test BgtaskConfig ParseTransientTaskExemptedQuatoList.
723 * @tc.type: FUNC
724 * @tc.require: DTS2025031836567
725 */
726 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_052, TestSize.Level1)
727 {
728 DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.clear();
729 nlohmann::json root = nullptr;
730 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuatoList(root);
731 EXPECT_EQ(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
732
733 nlohmann::json root2;
734 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuatoList(root2);
735 EXPECT_EQ(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
736
737 root2[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = 1;
738 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuatoList(root2);
739 EXPECT_EQ(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
740
741 nlohmann::json root3;
742 auto appInfo = nlohmann::json::array();
743 appInfo.push_back("com.myapplication.demo1");
744 appInfo.push_back("com.myapplication.demo2");
745 root3[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = appInfo;
746 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuatoList(root3);
747 EXPECT_NE(DelayedSingleton<BgtaskConfig>::GetInstance()->transientTaskExemptedQuatoList_.size(), 0);
748 }
749
750 /**
751 * @tc.name: BgTaskManagerUnitTest_053
752 * @tc.desc: test BgtaskConfig GetTransientTaskExemptedQuato.
753 * @tc.type: FUNC
754 * @tc.require: DTS2025031836567
755 */
756 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_053, TestSize.Level1)
757 {
758 int32_t timeValue = DelayedSingleton<BgtaskConfig>::GetInstance()->GetTransientTaskExemptedQuato();
759 EXPECT_NE(timeValue, 0);
760 }
761
762 /**
763 * @tc.name: BgTaskManagerUnitTest_054
764 * @tc.desc: test BgtaskConfig ParseTransientTaskExemptedQuato.
765 * @tc.type: FUNC
766 * @tc.require: DTS2025031836567
767 */
768 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_054, TestSize.Level1)
769 {
770 nlohmann::json root = nullptr;
771 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuato(root);
772 int32_t timeValue = DelayedSingleton<BgtaskConfig>::GetInstance()->GetTransientTaskExemptedQuato();
773 EXPECT_NE(timeValue, 0);
774
775 nlohmann::json root2;
776 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuato(root2);
777 int32_t timeValue2 = DelayedSingleton<BgtaskConfig>::GetInstance()->GetTransientTaskExemptedQuato();
778 EXPECT_NE(timeValue2, 0);
779
780 root2[TRANSIENT_EXEMPTED_QUOTA] = "1";
781 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuato(root2);
782 int32_t timeValue3 = DelayedSingleton<BgtaskConfig>::GetInstance()->GetTransientTaskExemptedQuato();
783 EXPECT_NE(timeValue3, 0);
784
785 nlohmann::json root3;
786 root3[TRANSIENT_EXEMPTED_QUOTA] = 0;
787 DelayedSingleton<BgtaskConfig>::GetInstance()->ParseTransientTaskExemptedQuato(root3);
788 int32_t timeValue4 = DelayedSingleton<BgtaskConfig>::GetInstance()->GetTransientTaskExemptedQuato();
789 EXPECT_EQ(timeValue4, 0);
790 }
791
792 /**
793 * @tc.name: BgTaskManagerUnitTest_055
794 * @tc.desc: test GetAllTransientTasks.
795 * @tc.type: FUNC
796 * @tc.require: issueIC1HDY
797 */
798 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_055, TestSize.Level0)
799 {
800 int32_t remainingQuota = -1;
801 std::vector<std::shared_ptr<DelaySuspendInfo>> list;
802 bgTransientTaskMgr_->isReady_.store(false);
803 EXPECT_EQ(bgTransientTaskMgr_->GetAllTransientTasks(remainingQuota, list), ERR_BGTASK_TRANSIENT_SYS_NOT_READY);
804
805
806 bgTransientTaskMgr_->isReady_.store(true);
807 EXPECT_EQ(bgTransientTaskMgr_->GetAllTransientTasks(remainingQuota, list), ERR_OK);
808
809 std::string bundleName = LAUNCHER_BUNDLE_NAME;
810 int32_t uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
811 if (uid == -1) {
812 bundleName = SCB_BUNDLE_NAME;
813 uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
814 }
815 auto keyInfo = std::make_shared<KeyInfo>(bundleName, uid);
816 bgTransientTaskMgr_->keyInfoMap_.clear();
817 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
818 EXPECT_EQ(bgTransientTaskMgr_->GetAllTransientTasks(remainingQuota, list), ERR_OK);
819 }
820 }
821 }
822