1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
18
19 #include "work_conn_manager.h"
20 #include "work_sched_hilog.h"
21
22 using namespace testing::ext;
23 using namespace std;
24
25 namespace OHOS {
26 namespace WorkScheduler {
27
28 class WorkConnManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
TearDownTestCase()31 static void TearDownTestCase() {}
SetUp()32 void SetUp() {}
TearDown()33 void TearDown() {}
34 static std::shared_ptr<WorkConnManager> workConnManager_;
35 };
36
37 class MyWorkConnManager : public WorkConnManager {
DisConnect(sptr<WorkSchedulerConnection> connect)38 bool DisConnect(sptr<WorkSchedulerConnection> connect)
39 {
40 return true;
41 }
42 };
43
44 std::shared_ptr<WorkConnManager> WorkConnManagerTest::workConnManager_ = nullptr;
45
SetUpTestCase()46 void WorkConnManagerTest::SetUpTestCase()
47 {
48 workConnManager_ = std::make_shared<WorkConnManager>();
49 }
50
51 /**
52 * @tc.name: AddConnInfo_001
53 * @tc.desc: Test WorkConnManager AddConnInfo.
54 * @tc.type: FUNC
55 * @tc.require: #I9HYBW
56 */
57 HWTEST_F(WorkConnManagerTest, AddConnInfo_001, TestSize.Level1)
58 {
59 string workId = "u1000_123";
60 sptr<WorkSchedulerConnection> connection;
61 workConnManager_->AddConnInfo(workId, connection);
62 EXPECT_TRUE(workConnManager_->connMap_.count(workId) > 0);
63 }
64
65 /**
66 * @tc.name: RemoveConnInfo_001
67 * @tc.desc: Test WorkConnManager RemoveConnInfo.
68 * @tc.type: FUNC
69 * @tc.require: #I9HYBW
70 */
71 HWTEST_F(WorkConnManagerTest, RemoveConnInfo_001, TestSize.Level1)
72 {
73 string workId = "u1000_123";
74 sptr<WorkSchedulerConnection> connection;
75 workConnManager_->AddConnInfo(workId, connection);
76 workConnManager_->RemoveConnInfo(workId);
77 EXPECT_FALSE(workConnManager_->connMap_.count(workId) > 0);
78 }
79
80 /**
81 * @tc.name: GetConnInfo_001
82 * @tc.desc: Test WorkConnManager GetConnInfo.
83 * @tc.type: FUNC
84 * @tc.require: #I9HYBW
85 */
86 HWTEST_F(WorkConnManagerTest, GetConnInfo_001, TestSize.Level1)
87 {
88 string workId = "u1000_123";
89 sptr<WorkSchedulerConnection> connection;
90 workConnManager_->AddConnInfo(workId, connection);
91 workConnManager_->GetConnInfo(workId);
92 EXPECT_TRUE(workConnManager_->connMap_.size() == 1);
93 }
94
95 /**
96 * @tc.name: GetConnInfo_002
97 * @tc.desc: Test WorkConnManager GetConnInfo.
98 * @tc.type: FUNC
99 * @tc.require: #I9HYBW
100 */
101 HWTEST_F(WorkConnManagerTest, GetConnInfo_002, TestSize.Level1)
102 {
103 workConnManager_->connMap_.clear();
104 string workId = "u1000_123";
105 sptr<WorkSchedulerConnection> ret = workConnManager_->GetConnInfo(workId);
106 EXPECT_TRUE(ret == nullptr);
107 }
108
109 /**
110 * @tc.name: StartWork_001
111 * @tc.desc: Test WorkConnManager StartWork.
112 * @tc.type: FUNC
113 * @tc.require: #I9HYBW
114 */
115 HWTEST_F(WorkConnManagerTest, StartWork_001, TestSize.Level1)
116 {
117 string workId = "u1000_123";
118 sptr<WorkSchedulerConnection> connection;
119 workConnManager_->AddConnInfo(workId, connection);
120
121 WorkInfo workInfo;
122 workInfo.workId_ = 123;
123 workInfo.bundleName_ = "com.unittest.bundleName";
124 workInfo.abilityName_ = "unittestAbility";
125 int32_t uid = 1234;
126 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
127 bool ret = workConnManager_->StartWork(workStatus);
128 EXPECT_FALSE(ret);
129 }
130
131 /**
132 * @tc.name: StartWork_002
133 * @tc.desc: Test WorkConnManager StartWork.
134 * @tc.type: FUNC
135 * @tc.require: #I9HYBW
136 */
137 HWTEST_F(WorkConnManagerTest, StartWork_002, TestSize.Level1)
138 {
139 WorkInfo workInfo;
140 workInfo.workId_ = 123;
141 workInfo.bundleName_ = "com.unittest.bundleName";
142 workInfo.abilityName_ = "unittestAbility";
143 int32_t uid = 1234;
144 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
145 bool ret = workConnManager_->StartWork(workStatus);
146 EXPECT_FALSE(ret);
147 }
148
149 /**
150 * @tc.name: DisConnect_001
151 * @tc.desc: Test WorkConnManager DisConnect.
152 * @tc.type: FUNC
153 * @tc.require: #I9HYBW
154 */
155 HWTEST_F(WorkConnManagerTest, DisConnect_001, TestSize.Level1)
156 {
157 sptr<WorkSchedulerConnection> connection;
158 bool ret = workConnManager_->DisConnect(connection);
159 EXPECT_FALSE(ret);
160 }
161
162 /**
163 * @tc.name: StopWork_001
164 * @tc.desc: Test WorkConnManager StopWork.
165 * @tc.type: FUNC
166 * @tc.require: #I9HYBW
167 */
168 HWTEST_F(WorkConnManagerTest, StopWork_001, TestSize.Level1)
169 {
170 workConnManager_->connMap_.clear();
171 WorkInfo workInfo;
172 workInfo.workId_ = 123;
173 workInfo.bundleName_ = "com.unittest.bundleName";
174 workInfo.abilityName_ = "unittestAbility";
175 int32_t uid = 1234;
176 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
177 bool ret = workConnManager_->StopWork(workStatus, false);
178 EXPECT_FALSE(ret);
179 }
180
181 /**
182 * @tc.name: StopWork_002
183 * @tc.desc: Test WorkConnManager StopWork.
184 * @tc.type: FUNC
185 * @tc.require: #I9HYBW
186 */
187 HWTEST_F(WorkConnManagerTest, StopWork_002, TestSize.Level1)
188 {
189 string workId = "u1000_123";
190 sptr<WorkSchedulerConnection> connection;
191 workConnManager_->AddConnInfo(workId, connection);
192
193 WorkInfo workInfo;
194 workInfo.workId_ = 123;
195 workInfo.bundleName_ = "com.unittest.bundleName";
196 workInfo.abilityName_ = "unittestAbility";
197 int32_t uid = 1234;
198 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
199 bool ret = workConnManager_->StopWork(workStatus, false);
200 EXPECT_FALSE(ret);
201 }
202
203 /**
204 * @tc.name: StopWork_003
205 * @tc.desc: Test WorkConnManager StopWork.
206 * @tc.type: FUNC
207 * @tc.require: #I9HYBW
208 */
209 HWTEST_F(WorkConnManagerTest, StopWork_003, TestSize.Level1)
210 {
211 MyWorkConnManager myWorkConnManager;
212
213 WorkInfo workInfo;
214 workInfo.workId_ = 123;
215 workInfo.bundleName_ = "com.unittest.bundleName";
216 workInfo.abilityName_ = "unittestAbility";
217 int32_t uid = 1000;
218 string workId = "u1000_123";
219 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
220 workStatus->workId_ = workId;
221
222 sptr<WorkSchedulerConnection> connection(new (std::nothrow) WorkSchedulerConnection(workStatus->workInfo_));
223 myWorkConnManager.AddConnInfo(workId, connection);
224 bool ret = myWorkConnManager.StopWork(workStatus, false);
225 EXPECT_TRUE(!ret);
226 }
227
228 /**
229 * @tc.name: StopWork_004
230 * @tc.desc: Test WorkConnManager StopWork.
231 * @tc.type: FUNC
232 * @tc.require: #I9HYBW
233 */
234 HWTEST_F(WorkConnManagerTest, StopWork_004, TestSize.Level1)
235 {
236 MyWorkConnManager myWorkConnManager;
237
238 WorkInfo workInfo;
239 workInfo.workId_ = 123;
240 workInfo.bundleName_ = "com.unittest.bundleName";
241 workInfo.abilityName_ = "unittestAbility";
242 int32_t uid = 1000;
243 string workId = "u1000_123";
244 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
245 workStatus->workId_ = workId;
246
247 sptr<WorkSchedulerConnection> connection(new (std::nothrow) WorkSchedulerConnection(workStatus->workInfo_));
248 myWorkConnManager.AddConnInfo(workId, connection);
249 bool ret = myWorkConnManager.StopWork(workStatus, true);
250 EXPECT_TRUE(!ret);
251 }
252
253 /**
254 * @tc.name: WriteStartWorkEvent_001
255 * @tc.desc: Test WorkConnManager WriteStartWorkEvent.
256 * @tc.type: FUNC
257 * @tc.require: #I9HYBW
258 */
259 HWTEST_F(WorkConnManagerTest, WriteStartWorkEvent_001, TestSize.Level1)
260 {
261 WorkInfo workInfo;
262 workInfo.workId_ = 123;
263 workInfo.bundleName_ = "com.unittest.bundleName";
264 workInfo.abilityName_ = "unittestAbility";
265 workInfo.RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_ANY);
266 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
267 workInfo.RequestBatteryLevel(80);
268 workInfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
269 workInfo.RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_LOW);
270 workInfo.RequestRepeatCycle(20000);
271 int32_t uid = 1234;
272 shared_ptr<WorkStatus> workStatus = make_shared<WorkStatus>(workInfo, uid);
273 workConnManager_->WriteStartWorkEvent(workStatus);
274 EXPECT_TRUE(workInfo.IsRepeat());
275 }
276 }
277 }