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 "expired_callback_proxy.h"
28 #include "expired_callback_stub.h"
29 #include "if_system_ability_manager.h"
30 #include "iservice_registry.h"
31 #include "resources_subscriber_mgr.h"
32 #include "system_ability_definition.h"
33 #include "want_agent.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 char LAUNCHER_BUNDLE_NAME[] = "com.ohos.launcher";
43 }
44 class BgTaskManagerUnitTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp();
49 void TearDown();
SleepForFC()50 inline void SleepForFC()
51 {
52 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
53 }
54
55 static std::shared_ptr<BgTransientTaskMgr> bgTransientTaskMgr_;
56
GetUidByBundleName(const std::string & bundleName,const int32_t userId)57 int32_t GetUidByBundleName(const std::string &bundleName, const int32_t userId)
58 {
59 sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
60 if (systemMgr == nullptr) {
61 return -1;
62 }
63
64 sptr<IRemoteObject> remoteObject = systemMgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
65 if (remoteObject == nullptr) {
66 return -1;
67 }
68
69 sptr<OHOS::AppExecFwk::IBundleMgr> bundleMgrProxy = iface_cast<OHOS::AppExecFwk::IBundleMgr>(remoteObject);
70 if (bundleMgrProxy == nullptr) {
71 return -1;
72 }
73
74 return bundleMgrProxy->GetUidByBundleName(bundleName, userId);
75 }
76 };
77
78 std::shared_ptr<BgTransientTaskMgr> BgTaskManagerUnitTest::bgTransientTaskMgr_ = nullptr;
79
SetUpTestCase()80 void BgTaskManagerUnitTest::SetUpTestCase()
81 {
82 bgTransientTaskMgr_ = DelayedSingleton<BgTransientTaskMgr>::GetInstance();
83 }
84
TearDownTestCase()85 void BgTaskManagerUnitTest::TearDownTestCase() {}
86
SetUp()87 void BgTaskManagerUnitTest::SetUp() {}
88
TearDown()89 void BgTaskManagerUnitTest::TearDown() {}
90
91 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {};
92
93 class TestExpiredCallbackStub : public ExpiredCallbackStub {
94 public:
OnExpired()95 void OnExpired() override {}
96 };
97
98 /**
99 * @tc.name: BgTaskManagerUnitTest_018
100 * @tc.desc: test BgTransientTaskMgr init.
101 * @tc.type: FUNC
102 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
103 */
104 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_018, TestSize.Level1)
105 {
106 EXPECT_EQ(bgTransientTaskMgr_->isReady_.load(), false);
107 bgTransientTaskMgr_->Init(AppExecFwk::EventRunner::Create("tdd_test_handler"));
108 EXPECT_EQ(bgTransientTaskMgr_->isReady_.load(), true);
109 }
110
111 /**
112 * @tc.name: BgTaskManagerUnitTest_019
113 * @tc.desc: test IsCallingInfoLegal.
114 * @tc.type: FUNC
115 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
116 */
117 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_019, TestSize.Level1)
118 {
119 std::string bundleName;
120 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(-1, -1, bundleName, nullptr), ERR_BGTASK_INVALID_PID_OR_UID);
121 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(1, 1, bundleName, nullptr), ERR_BGTASK_INVALID_BUNDLE_NAME);
122 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, DEFAULT_USERID);
123 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, nullptr), ERR_BGTASK_INVALID_CALLBACK);
124 sptr<ExpiredCallbackProxy> proxy1 = sptr<ExpiredCallbackProxy>(new ExpiredCallbackProxy(nullptr));
125 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, proxy1), ERR_BGTASK_INVALID_CALLBACK);
126 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
127 sptr<ExpiredCallbackProxy> proxy2 = sptr<ExpiredCallbackProxy>(
128 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
129 EXPECT_EQ(bgTransientTaskMgr_->IsCallingInfoLegal(uid, 1, bundleName, proxy2), ERR_OK);
130 }
131
132 /**
133 * @tc.name: BgTaskManagerUnitTest_020
134 * @tc.desc: test RequestSuspendDelay.
135 * @tc.type: FUNC
136 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
137 */
138 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_020, TestSize.Level1)
139 {
140 std::shared_ptr<DelaySuspendInfo> delayInfo = std::make_shared<DelaySuspendInfo>();
141 bgTransientTaskMgr_->isReady_.store(false);
142 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", nullptr, delayInfo), ERR_BGTASK_SYS_NOT_READY);
143 bgTransientTaskMgr_->isReady_.store(true);
144 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", nullptr, delayInfo), ERR_BGTASK_INVALID_CALLBACK);
145
146 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
147 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
148 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
149
150 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
151 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", proxy, delayInfo), ERR_BGTASK_CALLBACK_EXISTS);
152 bgTransientTaskMgr_->expiredCallbackMap_.clear();
153 EXPECT_EQ(bgTransientTaskMgr_->RequestSuspendDelay(u"test", proxy, delayInfo), ERR_OK);
154 }
155
156 /**
157 * @tc.name: BgTaskManagerUnitTest_021
158 * @tc.desc: test HandleTransientTaskSuscriberTask.
159 * @tc.type: FUNC
160 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
161 */
162 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_021, TestSize.Level1)
163 {
164 bgTransientTaskMgr_->handler_ = nullptr;
165 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(nullptr, TransientTaskEventType::TASK_START);
166 bgTransientTaskMgr_->handler_ = std::make_shared<AppExecFwk::EventHandler>(AppExecFwk::EventRunner::Create("tdd_test_handler"));
167 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(nullptr, TransientTaskEventType::TASK_START);
168
169 shared_ptr<TransientTaskAppInfo> appInfo = std::make_shared<TransientTaskAppInfo>();
170 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_START);
171
172 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
173 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber.GetImpl());
174 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_START);
175 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::TASK_END);
176 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::APP_TASK_START);
177 bgTransientTaskMgr_->HandleTransientTaskSuscriberTask(appInfo, TransientTaskEventType::APP_TASK_END);
178 bgTransientTaskMgr_->subscriberList_.clear();
179 EXPECT_TRUE(true);
180 }
181
182 /**
183 * @tc.name: BgTaskManagerUnitTest_022
184 * @tc.desc: test CancelSuspendDelay.
185 * @tc.type: FUNC
186 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
187 */
188 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_022, TestSize.Level1)
189 {
190 bgTransientTaskMgr_->keyInfoMap_.clear();
191 bgTransientTaskMgr_->isReady_.store(false);
192 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelay(-1), ERR_BGTASK_SYS_NOT_READY);
193 bgTransientTaskMgr_->isReady_.store(true);
194 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelay(1), ERR_BGTASK_INVALID_REQUEST_ID);
195 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, 100);
196 auto keyInfo = std::make_shared<KeyInfo>(LAUNCHER_BUNDLE_NAME, uid);
197 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
198 bgTransientTaskMgr_->CancelSuspendDelay(1);
199 EXPECT_TRUE(true);
200 }
201
202 /**
203 * @tc.name: BgTaskManagerUnitTest_023
204 * @tc.desc: test CancelSuspendDelayLocked.
205 * @tc.type: FUNC
206 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
207 */
208 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_023, TestSize.Level1)
209 {
210 EXPECT_EQ(bgTransientTaskMgr_->CancelSuspendDelayLocked(-1), ERR_BGTASK_CALLBACK_NOT_EXIST);
211
212 sptr<ExpiredCallbackProxy> proxy1 = sptr<ExpiredCallbackProxy>(new ExpiredCallbackProxy(nullptr));
213 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy1;
214 bgTransientTaskMgr_->CancelSuspendDelayLocked(-1);
215
216 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
217 sptr<ExpiredCallbackProxy> proxy2 = sptr<ExpiredCallbackProxy>(
218 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
219 bgTransientTaskMgr_->CancelSuspendDelayLocked(-1);
220 EXPECT_TRUE(true);
221 }
222
223 /**
224 * @tc.name: BgTaskManagerUnitTest_024
225 * @tc.desc: test ForceCancelSuspendDelay.
226 * @tc.type: FUNC
227 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
228 */
229 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_024, TestSize.Level1)
230 {
231 bgTransientTaskMgr_->keyInfoMap_.clear();
232 bgTransientTaskMgr_->ForceCancelSuspendDelay(1);
233
234 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
235 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
236 bgTransientTaskMgr_->ForceCancelSuspendDelay(1);
237 EXPECT_TRUE(true);
238 }
239
240 /**
241 * @tc.name: BgTaskManagerUnitTest_025
242 * @tc.desc: test GetRemainingDelayTime.
243 * @tc.type: FUNC
244 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
245 */
246 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_025, TestSize.Level1)
247 {
248 int32_t delayTime;
249 bgTransientTaskMgr_->isReady_.store(false);
250 EXPECT_EQ(bgTransientTaskMgr_->GetRemainingDelayTime(-1, delayTime), ERR_BGTASK_SYS_NOT_READY);
251 bgTransientTaskMgr_->isReady_.store(true);
252 EXPECT_EQ(bgTransientTaskMgr_->GetRemainingDelayTime(1, delayTime), ERR_BGTASK_INVALID_REQUEST_ID);
253 int32_t uid = GetUidByBundleName(LAUNCHER_BUNDLE_NAME, DEFAULT_USERID);
254 auto keyInfo = std::make_shared<KeyInfo>(LAUNCHER_BUNDLE_NAME, uid);
255 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
256 bgTransientTaskMgr_->GetRemainingDelayTime(1, delayTime);
257 EXPECT_TRUE(true);
258 }
259
260 /**
261 * @tc.name: BgTaskManagerUnitTest_026
262 * @tc.desc: test HandleExpiredCallbackDeath.
263 * @tc.type: FUNC
264 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
265 */
266 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_026, TestSize.Level1)
267 {
268 bgTransientTaskMgr_->HandleExpiredCallbackDeath(nullptr);
269 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
270 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
271 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
272 bgTransientTaskMgr_->expiredCallbackMap_.clear();
273 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
274
275 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
276 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
277
278 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
279 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
280 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
281 bgTransientTaskMgr_->HandleExpiredCallbackDeath(proxy);
282 bgTransientTaskMgr_->keyInfoMap_.clear();
283 bgTransientTaskMgr_->expiredCallbackMap_.clear();
284 EXPECT_TRUE(true);
285 }
286
287 /**
288 * @tc.name: BgTaskManagerUnitTest_027
289 * @tc.desc: test HandleSubscriberDeath.
290 * @tc.type: FUNC
291 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
292 */
293 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_027, TestSize.Level1)
294 {
295 bgTransientTaskMgr_->subscriberList_.clear();
296 bgTransientTaskMgr_->HandleSubscriberDeath(nullptr);
297 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
298 bgTransientTaskMgr_->HandleSubscriberDeath(subscriber.GetImpl());
299 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber.GetImpl());
300 bgTransientTaskMgr_->HandleSubscriberDeath(subscriber.GetImpl());
301 EXPECT_TRUE(true);
302 }
303
304 /**
305 * @tc.name: BgTaskManagerUnitTest_028
306 * @tc.desc: test HandleRequestExpired.
307 * @tc.type: FUNC
308 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
309 */
310 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_028, TestSize.Level1)
311 {
312 bgTransientTaskMgr_->keyInfoMap_.clear();
313 bgTransientTaskMgr_->expiredCallbackMap_.clear();
314 bgTransientTaskMgr_->HandleRequestExpired(1);
315 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub());
316 sptr<ExpiredCallbackProxy> proxy = sptr<ExpiredCallbackProxy>(
317 new ExpiredCallbackProxy(expiredCallbackStub->AsObject()));
318 bgTransientTaskMgr_->expiredCallbackMap_[1] = proxy;
319 bgTransientTaskMgr_->HandleRequestExpired(1);
320 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
321 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
322 bgTransientTaskMgr_->HandleRequestExpired(1);
323 EXPECT_TRUE(true);
324 }
325
326 /**
327 * @tc.name: BgTaskManagerUnitTest_029
328 * @tc.desc: test SubscribeBackgroundTask.
329 * @tc.type: FUNC
330 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
331 */
332 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_029, TestSize.Level1)
333 {
334 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(nullptr), ERR_BGTASK_INVALID_PARAM);
335 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
336 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
337 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
338 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
339 sptr<BackgroundTaskSubscriberProxy> subscirberProxy2
340 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(subscriber.GetImpl()));
341 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy2), ERR_OK);
342
343 bgTransientTaskMgr_->subscriberList_.emplace_back(subscirberProxy2);
344 EXPECT_EQ(bgTransientTaskMgr_->SubscribeBackgroundTask(subscirberProxy2), ERR_OK);
345 }
346
347 /**
348 * @tc.name: BgTaskManagerUnitTest_030
349 * @tc.desc: test UnsubscribeBackgroundTask.
350 * @tc.type: FUNC
351 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
352 */
353 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_030, TestSize.Level1)
354 {
355 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(nullptr), ERR_BGTASK_INVALID_PARAM);
356 TestBackgroundTaskSubscriber subscriber = TestBackgroundTaskSubscriber();
357 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
358 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
359 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy1), ERR_BGTASK_INVALID_PARAM);
360 sptr<BackgroundTaskSubscriberProxy> subscirberProxy2
361 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(subscriber.GetImpl()));
362 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy2), ERR_OK);
363
364 bgTransientTaskMgr_->subscriberList_.emplace_back(subscirberProxy2);
365 EXPECT_EQ(bgTransientTaskMgr_->UnsubscribeBackgroundTask(subscirberProxy2), ERR_OK);
366 }
367
368 /**
369 * @tc.name: BgTaskManagerUnitTest_031
370 * @tc.desc: test GetTransientTaskApps.
371 * @tc.type: FUNC
372 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
373 */
374 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_031, TestSize.Level1)
375 {
376 std::vector<std::shared_ptr<TransientTaskAppInfo>> list;
377 bgTransientTaskMgr_->keyInfoMap_.clear();
378 EXPECT_EQ(bgTransientTaskMgr_->GetTransientTaskApps(list), ERR_OK);
379
380 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
381 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
382 EXPECT_EQ(bgTransientTaskMgr_->GetTransientTaskApps(list), ERR_OK);
383 }
384
385 /**
386 * @tc.name: BgTaskManagerUnitTest_032
387 * @tc.desc: test ShellDump.
388 * @tc.type: FUNC
389 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
390 */
391 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_032, TestSize.Level1)
392 {
393 bgTransientTaskMgr_->keyInfoMap_.clear();
394 std::vector<std::string> dumpOption;
395 std::vector<std::string> dumpInfo;
396 bgTransientTaskMgr_->isReady_.store(false);
397 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_SYS_NOT_READY);
398 bgTransientTaskMgr_->isReady_.store(true);
399 dumpOption.emplace_back("-C");
400 dumpOption.emplace_back("All");
401 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
402 auto keyInfo = std::make_shared<KeyInfo>("bundleName", 1);
403 bgTransientTaskMgr_->keyInfoMap_[1] = keyInfo;
404 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
405 dumpOption.pop_back();
406 dumpOption.emplace_back("BATTARY_LOW");
407 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
408 dumpOption.pop_back();
409 dumpOption.emplace_back("BATTARY_OKAY");
410 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
411 dumpOption.pop_back();
412 dumpOption.emplace_back("DUMP_CANCEL");
413 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_OK);
414 dumpOption.pop_back();
415 dumpOption.emplace_back("invalid");
416 EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_PERMISSION_DENIED);
417 }
418
419 /**
420 * @tc.name: BgTaskManagerUnitTest_040
421 * @tc.desc: test ResourcesSubscriberMgr AddSubscriber.
422 * @tc.type: FUNC
423 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
424 */
425 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_040, TestSize.Level1)
426 {
427 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.clear();
428 sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
429 = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
430 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->AddSubscriber(subscirberProxy1),
431 ERR_BGTASK_INVALID_PARAM);
432 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscirberProxy1),
433 ERR_BGTASK_INVALID_PARAM);
434 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
435 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->deathRecipient_ = nullptr;
436 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->AddSubscriber(subscriber1.GetImpl()),
437 ERR_BGTASK_INVALID_PARAM);
438 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscriber1.GetImpl()),
439 ERR_BGTASK_OBJECT_EXISTS);
440
441 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->deathRecipient_
442 = new (std::nothrow) ObserverDeathRecipient();
443 EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscriber1.GetImpl()),
444 ERR_BGTASK_OBJECT_EXISTS);
445 }
446
447 /**
448 * @tc.name: BgTaskManagerUnitTest_041
449 * @tc.desc: test ResourcesSubscriberMgr OnResourceChanged.
450 * @tc.type: FUNC
451 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
452 */
453 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_041, TestSize.Level1)
454 {
455 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(nullptr,
456 EfficiencyResourcesEventType::APP_RESOURCE_APPLY);
457 auto callbackInfo = std::make_shared<ResourceCallbackInfo>();
458 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
459 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.emplace_back(subscriber1.GetImpl());
460
461 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
462 EfficiencyResourcesEventType::APP_RESOURCE_APPLY);
463 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
464 EfficiencyResourcesEventType::RESOURCE_APPLY);
465 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
466 EfficiencyResourcesEventType::APP_RESOURCE_RESET);
467 DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->OnResourceChanged(callbackInfo,
468 EfficiencyResourcesEventType::RESOURCE_RESET);
469 EXPECT_EQ((int32_t)DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.size(), 1);
470 }
471
472 /**
473 * @tc.name: BgTaskManagerUnitTest_042
474 * @tc.desc: test BgTransientTaskMgr NotifyTransientTaskSuscriber.
475 * @tc.type: FUNC
476 * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
477 */
478 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_042, TestSize.Level1)
479 {
480 auto taskInfo = std::make_shared<TransientTaskAppInfo>();
481 TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
482 bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber1.GetImpl());
483
484 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
485 TransientTaskEventType::TASK_START);
486 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
487 TransientTaskEventType::TASK_END);
488 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
489 TransientTaskEventType::APP_TASK_START);
490 bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
491 TransientTaskEventType::APP_TASK_END);
492 EXPECT_NE((int32_t)bgTransientTaskMgr_->subscriberList_.size(), 0);
493 }
494 }
495 }
496