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     void OnExpired() override {}
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("invalid");
438     EXPECT_EQ(bgTransientTaskMgr_->ShellDump(dumpOption, dumpInfo), ERR_BGTASK_PERMISSION_DENIED);
439 }
440 
441 /**
442  * @tc.name: BgTaskManagerUnitTest_040
443  * @tc.desc: test ResourcesSubscriberMgr AddSubscriber.
444  * @tc.type: FUNC
445  * @tc.require: issueI5IRJK issueI4QT3W issueI4QU0V
446  */
447 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_040, TestSize.Level1)
448 {
449     DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->subscriberList_.clear();
450     sptr<BackgroundTaskSubscriberProxy> subscirberProxy1
451         = sptr<BackgroundTaskSubscriberProxy>(new BackgroundTaskSubscriberProxy(nullptr));
452     EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->AddSubscriber(subscirberProxy1),
453         ERR_BGTASK_INVALID_PARAM);
454     EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscirberProxy1),
455         ERR_BGTASK_INVALID_PARAM);
456     TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
457     DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->deathRecipient_ = nullptr;
458     EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->AddSubscriber(subscriber1.GetImpl()),
459         ERR_BGTASK_INVALID_PARAM);
460     EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscriber1.GetImpl()),
461         ERR_BGTASK_OBJECT_EXISTS);
462 
463     DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->deathRecipient_
464         = new (std::nothrow) ObserverDeathRecipient();
465     EXPECT_EQ(DelayedSingleton<ResourcesSubscriberMgr>::GetInstance()->RemoveSubscriber(subscriber1.GetImpl()),
466         ERR_BGTASK_OBJECT_EXISTS);
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     auto taskInfo = std::make_shared<TransientTaskAppInfo>();
503     TestBackgroundTaskSubscriber subscriber1 = TestBackgroundTaskSubscriber();
504     bgTransientTaskMgr_->subscriberList_.emplace_back(subscriber1.GetImpl());
505 
506     bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
507         TransientTaskEventType::TASK_START);
508     bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
509         TransientTaskEventType::TASK_END);
510     bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
511         TransientTaskEventType::APP_TASK_START);
512     bgTransientTaskMgr_->NotifyTransientTaskSuscriber(taskInfo,
513         TransientTaskEventType::APP_TASK_END);
514     EXPECT_NE((int32_t)bgTransientTaskMgr_->subscriberList_.size(), 0);
515 }
516 
517 /**
518  * @tc.name: BgTaskManagerUnitTest_043
519  * @tc.desc: test BgTransientTaskMgr PauseTransientTaskTimeForInner.
520  * @tc.type: FUNC
521  * @tc.require: issueI936BL
522  */
523 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_043, TestSize.Level1)
524 {
525     int32_t uid = -1;
526     bgTransientTaskMgr_->isReady_.store(false);
527     EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_SYS_NOT_READY);
528 
529     bgTransientTaskMgr_->isReady_.store(true);
530     EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_INVALID_PID_OR_UID);
531 
532     uid = 1;
533     EXPECT_EQ(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_BGTASK_SERVICE_INNER_ERROR);
534 
535     std::string bundleName = LAUNCHER_BUNDLE_NAME;
536     uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
537     if (uid == -1) {
538         bundleName = SCB_BUNDLE_NAME;
539         uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
540     }
541     EXPECT_NE(bgTransientTaskMgr_->PauseTransientTaskTimeForInner(uid), ERR_OK);
542 }
543 
544 /**
545  * @tc.name: BgTaskManagerUnitTest_044
546  * @tc.desc: test BgTransientTaskMgr StartTransientTaskTimeForInner.
547  * @tc.type: FUNC
548  * @tc.require: issueI936BL
549  */
550 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_044, TestSize.Level1)
551 {
552     int32_t uid = -1;
553     bgTransientTaskMgr_->isReady_.store(false);
554     EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_SYS_NOT_READY);
555 
556     bgTransientTaskMgr_->isReady_.store(true);
557     EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_INVALID_PID_OR_UID);
558 
559     uid = 1;
560     EXPECT_EQ(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_BGTASK_SERVICE_INNER_ERROR);
561 
562     std::string bundleName = LAUNCHER_BUNDLE_NAME;
563     uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
564     if (uid == -1) {
565         bundleName = SCB_BUNDLE_NAME;
566         uid = GetUidByBundleName(bundleName, DEFAULT_USERID);
567     }
568     EXPECT_NE(bgTransientTaskMgr_->StartTransientTaskTimeForInner(uid), ERR_OK);
569 }
570 
571 /**
572  * @tc.name: BgTaskManagerUnitTest_045
573  * @tc.desc: test BgTransientTaskMgr SendCloudConfig.
574  * @tc.type: FUNC
575  * @tc.require: issueI936BL
576  */
577 HWTEST_F(BgTaskManagerUnitTest, BgTaskManagerUnitTest_045, TestSize.Level1)
578 {
579     bgTransientTaskMgr_->isReady_.store(false);
580     EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig("", ConfigDataSourceType::CONFIG_CLOUD), ERR_BGTASK_SYS_NOT_READY);
581 
582     bgTransientTaskMgr_->isReady_.store(true);
583     EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig("", ConfigDataSourceType::CONFIG_CLOUD), ERR_PARAM_NUMBER_ERR);
584 
585     auto appInfo = nlohmann::json::array();
586     appInfo.push_back("com.myapplication.demo1");
587     appInfo.push_back("com.myapplication.demo2");
588     nlohmann::json appParam;
589     appParam[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = appInfo;
590     appParam[TRANSIENT_ERR_DELAYED_FROZEN_TIME] = TRANSIENT_EXEMPTED_QUOTA_TIME;
591     const std::string strParam = appParam.dump(JSON_FORMAT_DUMP);
592     EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig(strParam, ConfigDataSourceType::CONFIG_SUSPEND_MANAGER), ERR_OK);
593 
594     nlohmann::json param;
595     param[TRANSIENT_EXEMPTED_QUOTA] = TRANSIENT_EXEMPTED_QUOTA_TIME;
596     nlohmann::json params;
597     params[TRANSIENT_ERR_DELAYED_FROZEN_LIST] = appInfo;
598     params[CONFIG_JSON_INDEX_SUSPEND_SECOND] = param;
599     nlohmann::json cloudConfig;
600     cloudConfig[CONFIG_JSON_INDEX_TOP] = params;
601     const std::string cloudConfigStr = cloudConfig.dump(JSON_FORMAT_DUMP);
602     EXPECT_EQ(bgTransientTaskMgr_->SetBgTaskConfig(cloudConfigStr, ConfigDataSourceType::CONFIG_CLOUD), ERR_OK);
603 }
604 }
605 }
606