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
20 #include "gtest/gtest.h"
21
22 #define private public
23
24 #include "bgtaskmgr_inner_errors.h"
25 #include "background_task_subscriber.h"
26 #include "bg_continuous_task_mgr.h"
27 #include "want_agent.h"
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace BackgroundTaskMgr {
33 namespace {
34 static constexpr int32_t SLEEP_TIME = 500;
35 static constexpr int32_t PROMPT_NUMS = 10;
36 }
37 class BgContinuousTaskMgrTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
SleepForFC()43 inline void SleepForFC()
44 {
45 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
46 }
47
48 static std::shared_ptr<BgContinuousTaskMgr> bgContinuousTaskMgr_;
49 };
50
51 std::shared_ptr<BgContinuousTaskMgr> BgContinuousTaskMgrTest::bgContinuousTaskMgr_ = nullptr;
52
SetUpTestCase()53 void BgContinuousTaskMgrTest::SetUpTestCase()
54 {
55 bgContinuousTaskMgr_ = BgContinuousTaskMgr::GetInstance();
56 std::fill_n(std::back_inserter(bgContinuousTaskMgr_->continuousTaskText_), PROMPT_NUMS, "bgmode_test");
57 bgContinuousTaskMgr_->isSysReady_.store(true);
58 }
59
TearDownTestCase()60 void BgContinuousTaskMgrTest::TearDownTestCase() {}
61
SetUp()62 void BgContinuousTaskMgrTest::SetUp() {}
63
TearDown()64 void BgContinuousTaskMgrTest::TearDown()
65 {
66 std::vector<string> dumpOption;
67 dumpOption.emplace_back("-C");
68 dumpOption.emplace_back("--cancel_all");
69 std::vector<string> dumpInfo;
70 bgContinuousTaskMgr_->ShellDump(dumpOption, dumpInfo);
71 }
72
73 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {
74 public:
OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)75 void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo>
76 &continuousTaskCallbackInfo) override {}
77
OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)78 void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo>
79 &continuousTaskCallbackInfo) override {}
80 };
81
82 /**
83 * @tc.name: StartBackgroundRunning_001
84 * @tc.desc: start background runnging use new api test.
85 * @tc.type: FUNC
86 * @tc.require: SR000GGT7U AR000GH6ER AR000GH6EM AR000GH6EN AR000GH6EO
87 */
88 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_001, TestSize.Level1)
89 {
90 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
91 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
92 EXPECT_NE(taskParam, nullptr);
93 taskParam->appName_ = "Entry";
94 taskParam->isNewApi_ = true;
95 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
96 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
97 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
98 taskParam->abilityName_ = "";
99 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
100 taskParam->abilityName_ = "ability1";
101 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
102 taskParam->bgModeId_ = 9;
103 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam),
104 (int32_t)ERR_BGTASK_KEEPING_TASK_VERIFY_ERR);
105 taskParam->bgModeId_ = 1;
106 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_INVALID_BGMODE);
107 taskParam->bgModeId_ = 4;
108 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
109 }
110
111 /**
112 * @tc.name: StartBackgroundRunning_002
113 * @tc.desc: start background runnging use old api test.
114 * @tc.type: FUNC
115 * @tc.require: SR000GGT7T AR000GH6ER AR000GH6EP AR000GJ9PR AR000GH6G8
116 */
117 HWTEST_F(BgContinuousTaskMgrTest, StartBackgroundRunning_002, TestSize.Level1)
118 {
119 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(nullptr), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
120 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
121 EXPECT_NE(taskParam, nullptr);
122 taskParam->appName_ = "Entry";
123 taskParam->isNewApi_ = false;
124 taskParam->bgModeId_ = 0;
125 taskParam->abilityName_ = "";
126 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_BGTASK_CHECK_TASK_PARAM);
127 taskParam->abilityName_ = "ability1";
128 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StartBackgroundRunning(taskParam), (int32_t)ERR_OK);
129 }
130
131 /**
132 * @tc.name: StopBackgroundRunning_001
133 * @tc.desc: stop background runnging test.
134 * @tc.type: FUNC
135 * @tc.require: SR000GGT7V AR000GH6ES AR000GH6EM AR000GH6G9 AR000GH56K
136 */
137 HWTEST_F(BgContinuousTaskMgrTest, StopBackgroundRunning_001, TestSize.Level1)
138 {
139 sptr<ContinuousTaskParam> taskParam = new (std::nothrow) ContinuousTaskParam();
140 EXPECT_NE(taskParam, nullptr);
141 taskParam->appName_ = "Entry";
142 taskParam->wantAgent_ = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
143 taskParam->abilityName_ = "ability1";
144 taskParam->bgModeId_ = 4;
145 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning(""), (int32_t)ERR_BGTASK_INVALID_PARAM);
146 SleepForFC();
147 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1"), (int32_t)ERR_BGTASK_OBJECT_NOT_EXIST);
148 SleepForFC();
149 bgContinuousTaskMgr_->StartBackgroundRunning(taskParam);
150 SleepForFC();
151 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->StopBackgroundRunning("ability1"), (int32_t)ERR_OK);
152 }
153
154 /**
155 * @tc.name: SubscribeContinuousTask_001
156 * @tc.desc: subscribe continuous task event callback test.
157 * @tc.type: FUNC
158 * @tc.require: SR000GGT81 AR000GH6EM AR000GH6G9 AR000GH6ET
159 */
160 HWTEST_F(BgContinuousTaskMgrTest, SubscribeContinuousTask_001, TestSize.Level1)
161 {
162 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(nullptr), (int32_t)ERR_BGTASK_INVALID_PARAM);
163 SleepForFC();
164 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
165 EXPECT_NE(subscriber, nullptr);
166 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->AddSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
167 }
168
169 /**
170 * @tc.name: UnsubscribeContinuousTask_001
171 * @tc.desc: unsubscribe continuous task event callback test.
172 * @tc.type: FUNC
173 * @tc.require: SR000GGT7U AR000GH6EM AR000GH6G9 AR000GH6ET
174 */
175 HWTEST_F(BgContinuousTaskMgrTest, UnsubscribeContinuousTask_001, TestSize.Level1)
176 {
177 auto subscriber = new (std::nothrow) TestBackgroundTaskSubscriber();
178 EXPECT_NE(subscriber, nullptr);
179 bgContinuousTaskMgr_->AddSubscriber(subscriber->GetImpl());
180 SleepForFC();
181 EXPECT_EQ((int32_t)bgContinuousTaskMgr_->RemoveSubscriber(subscriber->GetImpl()), (int32_t)ERR_OK);
182 }
183 } // namespace BackgroundTaskMgr
184 } // namespace OHOS