1 /*
2 * Copyright (c) 2021-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 "task_test.h"
17
18 #include <chrono>
19 #include <thread>
20
21 #include "dh_utils_tool.h"
22 #include "distributed_hardware_errno.h"
23 #include "task_factory.h"
24 #include "mock_disable_task.h"
25 #include "mock_enable_task.h"
26 #include "mock_meta_disable_task.h"
27 #include "mock_meta_enable_task.h"
28 #include "mock_offline_task.h"
29 #include "mock_online_task.h"
30 #include "mock_task_factory.h"
31 #include "mock_task_utils.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace DistributedHardware {
37 namespace {
38 const std::string DEV_ID_1 = "bb536a637105409e904d4da83790a4a8";
39 const std::string DEV_NETWORK_ID_1 = "nt36a637105409e904d4da83790a4a8";
40 const MockDevInfo DEV_INFO_11 = { DEV_NETWORK_ID_1, DEV_ID_1, "Camera_1", DHType::CAMERA };
41 const MockDevInfo DEV_INFO_12 = { DEV_NETWORK_ID_1, DEV_ID_1, "Gps_1", DHType::GPS };
42 const MockDevInfo DEV_INFO_13 = { DEV_NETWORK_ID_1, DEV_ID_1, "Audio_1", DHType::AUDIO };
43 const MockDevInfo DEV_INFO_14 = { DEV_NETWORK_ID_1, DEV_ID_1, "Display_1", DHType::SCREEN };
44 const MockDevInfo DEV_INFO_15 = { DEV_NETWORK_ID_1, DEV_ID_1, "Input_1", DHType::INPUT };
45
46 const std::string DEV_ID_2 = "06d177ffa09543389f3b445b4722f9be";
47 const std::string DEV_NETWORK_ID_2 = "ntd177ffa09543389f3b445b4722f9be";
48 const MockDevInfo DEV_INFO_21 = { DEV_NETWORK_ID_2, DEV_ID_2, "Camera_1", DHType::CAMERA };
49 const MockDevInfo DEV_INFO_22 = { DEV_NETWORK_ID_2, DEV_ID_2, "Gps_1", DHType::GPS };
50 const MockDevInfo DEV_INFO_23 = { DEV_NETWORK_ID_2, DEV_ID_2, "Audio_1", DHType::AUDIO };
51 const MockDevInfo DEV_INFO_24 = { DEV_NETWORK_ID_2, DEV_ID_2, "Display_1", DHType::SCREEN };
52 const MockDevInfo DEV_INFO_25 = { DEV_NETWORK_ID_2, DEV_ID_2, "Input_1", DHType::INPUT };
53
54 const TaskParam TASK_PARAM_1 = {
55 .networkId = DEV_NETWORK_ID_1,
56 .uuid = DEV_ID_1,
57 .dhId = "",
58 .dhType = DHType::UNKNOWN
59 };
60
61 const TaskParam TASK_PARAM_2 = {
62 .networkId = DEV_NETWORK_ID_2,
63 .uuid = DEV_ID_2,
64 .dhId = "",
65 .dhType = DHType::UNKNOWN
66 };
67 }
68
SetUpTestCase(void)69 void TaskTest::SetUpTestCase(void)
70 {
71 }
72
TearDownTestCase(void)73 void TaskTest::TearDownTestCase(void)
74 {
75 }
76
SetUp()77 void TaskTest::SetUp()
78 {
79 }
80
TearDown()81 void TaskTest::TearDown()
82 {
83 }
84
85 /**
86 * @tc.name: task_test_001
87 * @tc.desc: Verify the Execute OnLineTask function
88 * @tc.type: FUNC
89 * @tc.require: AR000GHSKP
90 */
91 HWTEST_F(TaskTest, task_test_001, TestSize.Level0)
92 {
93 std::shared_ptr<MockOnLineTask> onlineTask = std::static_pointer_cast<MockOnLineTask>(
94 MockTaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, TASK_PARAM_1, nullptr));
95 onlineTask->SetOnLineDevInfos({ DEV_INFO_11, DEV_INFO_12, DEV_INFO_13, DEV_INFO_14, DEV_INFO_15 });
96
97 TaskExecutor::GetInstance().PushTask(onlineTask);
98
99 ASSERT_EQ(DH_FWK_SUCCESS, TaskBoard::GetInstance().WaitForALLTaskFinish());
100 ASSERT_TRUE(TaskBoard::GetInstance().IsAllTaskFinish());
101 }
102
103 /**
104 * @tc.name: task_test_002
105 * @tc.desc: Verify the Execute OnLineTask function
106 * @tc.type: FUNC
107 * @tc.require: AR000GHSKN
108 */
109 HWTEST_F(TaskTest, task_test_002, TestSize.Level0)
110 {
111 std::shared_ptr<MockOnLineTask> onlineTask1 = std::static_pointer_cast<MockOnLineTask>(
112 MockTaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, TASK_PARAM_1, nullptr));
113 onlineTask1->SetOnLineDevInfos({ DEV_INFO_11, DEV_INFO_12, DEV_INFO_13, DEV_INFO_14, DEV_INFO_15 });
114
115 std::shared_ptr<MockOnLineTask> onlineTask2 = std::static_pointer_cast<MockOnLineTask>(
116 MockTaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, TASK_PARAM_2, nullptr));
117 onlineTask2->SetOnLineDevInfos({ DEV_INFO_21, DEV_INFO_22, DEV_INFO_23, DEV_INFO_24, DEV_INFO_25 });
118
119 TaskExecutor::GetInstance().PushTask(onlineTask1);
120 TaskExecutor::GetInstance().PushTask(onlineTask2);
121
122 ASSERT_EQ(DH_FWK_SUCCESS, TaskBoard::GetInstance().WaitForALLTaskFinish());
123 ASSERT_TRUE(TaskBoard::GetInstance().IsAllTaskFinish());
124 }
125
126 /**
127 * @tc.name: task_test_004
128 * @tc.desc: Verify the Execute OnLineTask and OffLineTask function
129 * @tc.type: FUNC
130 * @tc.require: AR000GHSJE
131 */
132 HWTEST_F(TaskTest, task_test_004, TestSize.Level0)
133 {
134 std::shared_ptr<MockOnLineTask> onlineTask1 = std::static_pointer_cast<MockOnLineTask>(
135 MockTaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, TASK_PARAM_1, nullptr));
136 onlineTask1->SetOnLineDevInfos({ DEV_INFO_11, DEV_INFO_12, DEV_INFO_13, DEV_INFO_14, DEV_INFO_15 });
137
138 std::shared_ptr<MockOnLineTask> onlineTask2 = std::static_pointer_cast<MockOnLineTask>(
139 MockTaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, TASK_PARAM_2, nullptr));
140 onlineTask2->SetOnLineDevInfos({ DEV_INFO_21, DEV_INFO_22, DEV_INFO_23, DEV_INFO_24, DEV_INFO_25 });
141
142 TaskExecutor::GetInstance().PushTask(onlineTask1);
143
144 ASSERT_EQ(ERR_DH_FWK_TASK_TIMEOUT, TaskBoard::GetInstance().WaitForALLTaskFinish());
145 ASSERT_FALSE(TaskBoard::GetInstance().IsAllTaskFinish());
146
147 TaskExecutor::GetInstance().PushTask(onlineTask2);
148 ASSERT_EQ(DH_FWK_SUCCESS, TaskBoard::GetInstance().WaitForALLTaskFinish());
149 }
150
151 /**
152 * @tc.name: task_test_005
153 * @tc.desc: Verify the PushTask function
154 * @tc.type: FUNC
155 * @tc.require: AR000GHSJE
156 */
157 HWTEST_F(TaskTest, task_test_005, TestSize.Level0)
158 {
159 std::shared_ptr<Task> task = nullptr;
160 TaskExecutor::GetInstance().PushTask(task);
161 ASSERT_EQ(true, TaskExecutor::GetInstance().taskQueue_.empty());
162 }
163
164 /**
165 * @tc.name: task_test_006
166 * @tc.desc: Verify the CreateTask function
167 * @tc.type: FUNC
168 * @tc.require: AR000GHSJE
169 */
170 HWTEST_F(TaskTest, task_test_006, TestSize.Level0)
171 {
172 TaskParam taskParam;
173 auto task = TaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, taskParam, nullptr);
174 ASSERT_NE(nullptr, task);
175 }
176
177 /**
178 * @tc.name: task_test_007
179 * @tc.desc: Verify the CreateTask function
180 * @tc.type: FUNC
181 * @tc.require: AR000GHSJE
182 */
183 HWTEST_F(TaskTest, task_test_007, TestSize.Level0)
184 {
185 TaskParam taskParam;
186 auto task = TaskFactory::GetInstance().CreateTask(TaskType::DISABLE, taskParam, nullptr);
187 ASSERT_NE(nullptr, task);
188 }
189
190 /**
191 * @tc.name: task_test_008
192 * @tc.desc: Verify the CreateTask function
193 * @tc.type: FUNC
194 * @tc.require: AR000GHSJE
195 */
196 HWTEST_F(TaskTest, task_test_008, TestSize.Level0)
197 {
198 TaskParam taskParam;
199 auto task = TaskFactory::GetInstance().CreateTask(TaskType::ON_LINE, taskParam, nullptr);
200 ASSERT_NE(nullptr, task);
201 }
202
203 /**
204 * @tc.name: task_test_009
205 * @tc.desc: Verify the CreateTask function
206 * @tc.type: FUNC
207 * @tc.require: AR000GHSJE
208 */
209 HWTEST_F(TaskTest, task_test_009, TestSize.Level0)
210 {
211 TaskParam taskParam;
212 auto task = TaskFactory::GetInstance().CreateTask(TaskType::OFF_LINE, taskParam, nullptr);
213 ASSERT_NE(nullptr, task);
214 }
215
216 /**
217 * @tc.name: task_test_010
218 * @tc.desc: Verify the CreateTask function
219 * @tc.type: FUNC
220 * @tc.require: AR000GHSJE
221 */
222 HWTEST_F(TaskTest, task_test_010, TestSize.Level0)
223 {
224 TaskParam taskParam;
225 auto task = TaskFactory::GetInstance().CreateTask(TaskType::UNKNOWN, taskParam, nullptr);
226 ASSERT_EQ(nullptr, task);
227 }
228
229 /**
230 * @tc.name: task_test_011
231 * @tc.desc: Verify the RemoveTaskInner function
232 * @tc.type: FUNC
233 * @tc.require: AR000GHSKN
234 */
235 HWTEST_F(TaskTest, task_test_011, TestSize.Level0)
236 {
237 std::string taskId;
238 TaskBoard::GetInstance().tasks_.clear();
239 TaskBoard::GetInstance().RemoveTaskInner(taskId);
240 ASSERT_TRUE(TaskBoard::GetInstance().enabledDevices_.empty());
241 }
242
243 /**
244 * @tc.name: task_test_012
245 * @tc.desc: Verify the DumpAllTasks function
246 * @tc.type: FUNC
247 * @tc.require: AR000GHSKN
248 */
249 HWTEST_F(TaskTest, task_test_012, TestSize.Level0)
250 {
251 std::vector<TaskDump> taskInfos;
252 std::shared_ptr<Task> childrenTask = std::make_shared<OnLineTask>("networkId", "uuid", "udid", "dhId",
253 DHType::AUDIO);
254 TaskBoard::GetInstance().tasks_.insert(std::make_pair("", childrenTask));
255 TaskBoard::GetInstance().DumpAllTasks(taskInfos);
256 ASSERT_TRUE(TaskBoard::GetInstance().enabledDevices_.empty());
257 }
258
259 /**
260 * @tc.name: task_test_013
261 * @tc.desc: Verify the SaveEnabledDevice function
262 * @tc.type: FUNC
263 * @tc.require: AR000GHSKN
264 */
265 HWTEST_F(TaskTest, task_test_013, TestSize.Level0)
266 {
267 std::string enabledDeviceKey;
268 TaskParam taskParam;
269 TaskBoard::GetInstance().SaveEnabledDevice(enabledDeviceKey, taskParam);
270 ASSERT_EQ(false, TaskBoard::GetInstance().enabledDevices_.empty());
271 }
272
273 /**
274 * @tc.name: task_test_014
275 * @tc.desc: Verify the RemoveEnabledDevice function
276 * @tc.type: FUNC
277 * @tc.require: AR000GHSKN
278 */
279 HWTEST_F(TaskTest, task_test_014, TestSize.Level0)
280 {
281 std::string enabledDeviceKey;
282 TaskBoard::GetInstance().RemoveEnabledDevice(enabledDeviceKey);
283 ASSERT_TRUE(TaskBoard::GetInstance().enabledDevices_.empty());
284 }
285
286 /**
287 * @tc.name: task_test_015
288 * @tc.desc: Verify the GetEnabledDevice function
289 * @tc.type: FUNC
290 * @tc.require: AR000GHSKN
291 */
292 HWTEST_F(TaskTest, task_test_015, TestSize.Level0)
293 {
294 TaskBoard::GetInstance().enabledDevices_.clear();
295 auto ret = TaskBoard::GetInstance().GetEnabledDevice();
296 ASSERT_TRUE(ret.empty());
297 }
298
299 /**
300 * @tc.name: task_test_016
301 * @tc.desc: Verify the DoTask function
302 * @tc.type: FUNC
303 * @tc.require: AR000GHSKN
304 */
305 HWTEST_F(TaskTest, task_test_016, TestSize.Level0)
306 {
307 TaskParam taskParam;
308 auto task = TaskFactory::GetInstance().CreateTask(TaskType::DISABLE, taskParam, nullptr);
309 task->DoTask();
310 ASSERT_TRUE(task->childrenTasks_.empty());
311 }
312
313 /**
314 * @tc.name: task_test_017
315 * @tc.desc: Verify the DoTask function
316 * @tc.type: FUNC
317 * @tc.require: AR000GHSKN
318 */
319 HWTEST_F(TaskTest, task_test_017, TestSize.Level0)
320 {
321 TaskParam taskParam;
322 auto task = TaskFactory::GetInstance().CreateTask(TaskType::ENABLE, taskParam, nullptr);
323 task->DoTask();
324 ASSERT_TRUE(task->childrenTasks_.empty());
325 }
326
327 /**
328 * @tc.name: task_test_018
329 * @tc.desc: Verify the CreateDisableTask function
330 * @tc.type: FUNC
331 * @tc.require: AR000GHSKN
332 */
333 HWTEST_F(TaskTest, task_test_018, TestSize.Level0)
334 {
335 TaskParam taskParam;
336 auto task = TaskFactory::GetInstance().CreateTask(TaskType::OFF_LINE, taskParam, nullptr);
337 std::vector<TaskStep> taskSteps;
338 taskSteps.push_back(TaskStep::UNREGISTER_OFFLINE_DISTRIBUTED_HARDWARE);
339 task->SetTaskSteps(taskSteps);
340 task->DoTask();
341 ASSERT_TRUE(task->childrenTasks_.empty());
342 }
343
344 /**
345 * @tc.name: task_test_019
346 * @tc.desc: Verify the ClearOffLineInfo function
347 * @tc.type: FUNC
348 * @tc.require: AR000GHSKN
349 */
350 HWTEST_F(TaskTest, task_test_019, TestSize.Level0)
351 {
352 TaskParam taskParam;
353 auto task = TaskFactory::GetInstance().CreateTask(TaskType::OFF_LINE, taskParam, nullptr);
354 std::vector<TaskStep> taskSteps;
355 taskSteps.push_back(TaskStep::CLEAR_OFFLINE_INFO);
356 task->SetTaskSteps(taskSteps);
357 task->DoTask();
358 ASSERT_TRUE(task->childrenTasks_.empty());
359 }
360
361 /**
362 * @tc.name: task_test_020
363 * @tc.desc: Verify the AddChildrenTask function
364 * @tc.type: FUNC
365 * @tc.require: AR000GHSKN
366 */
367 HWTEST_F(TaskTest, task_test_020, TestSize.Level0)
368 {
369 std::shared_ptr<Task> childrenTask = std::make_shared<OnLineTask>("networkId", "uuid", "udid", "dhId",
370 DHType::AUDIO);
371 TaskParam taskParam;
372 auto task = TaskFactory::GetInstance().CreateTask(TaskType::OFF_LINE, taskParam, nullptr);
373 task->AddChildrenTask(childrenTask);
374 ASSERT_TRUE(task->childrenTasks_.empty());
375 }
376
377 /**
378 * @tc.name: task_test_021
379 * @tc.desc: Verify the TriggerTask function
380 * @tc.type: FUNC
381 * @tc.require: AR000GHSJE
382 */
383 HWTEST_F(TaskTest, task_test_021, TestSize.Level0)
384 {
385 TaskExecutor::GetInstance().taskThreadFlag_ = false;
386 TaskExecutor::GetInstance().TriggerTask();
387 ASSERT_EQ(true, TaskExecutor::GetInstance().taskQueue_.empty());
388 }
389
390 HWTEST_F(TaskTest, task_test_022, TestSize.Level0)
391 {
392 TaskParam taskParam;
393 auto task = TaskFactory::GetInstance().CreateTask(TaskType::META_ENABLE, taskParam, nullptr);
394 task->DoTask();
395 ASSERT_TRUE(task->childrenTasks_.empty());
396 }
397
398 HWTEST_F(TaskTest, task_test_023, TestSize.Level0)
399 {
400 TaskParam taskParam;
401 auto task = TaskFactory::GetInstance().CreateTask(TaskType::OFF_LINE, taskParam, nullptr);
402 std::vector<TaskStep> taskSteps;
403 taskSteps.push_back(TaskStep::META_DISABLE_TASK);
404 task->SetTaskSteps(taskSteps);
405 task->DoTask();
406 ASSERT_EQ(true, task->childrenTasks_.empty());
407 }
408 } // namespace DistributedHardware
409 } // namespace OHOS
410