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