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